import { default as React } from 'react';

export interface RecordingConfig {
    video: VideoConfig;
    audio: AudioConfig;
    webcam: WebcamConfig;
    output: OutputConfig;
    presentation: PresentationRecordingConfig;
}
export interface VideoConfig {
    width: number;
    height: number;
    frameRate: number;
    videoBitsPerSecond?: number;
    codec?: string;
}
export interface AudioConfig {
    enabled: boolean;
    sampleRate?: number;
    audioBitsPerSecond?: number;
    echoCancellation?: boolean;
    noiseSuppression?: boolean;
    autoGainControl?: boolean;
    channelCount?: number;
}
export interface WebcamConfig {
    enabled: boolean;
    deviceId?: string;
    position: WebcamPosition;
    size: WebcamSize;
    shape: 'circle' | 'rectangle' | 'rounded';
    borderWidth?: number;
    borderColor?: string;
    shadow?: boolean;
    mirror?: boolean;
    greenScreen?: {
        enabled: boolean;
        color?: string;
        threshold?: number;
    };
}
export type WebcamPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'custom';
export type WebcamSize = 'small' | 'medium' | 'large' | {
    width: number;
    height: number;
};
export interface OutputConfig {
    format: 'webm' | 'mp4';
    filename?: string;
    quality: 'low' | 'medium' | 'high' | 'ultra';
    includeTimestamps?: boolean;
}
export interface PresentationRecordingConfig {
    slideChanges: boolean;
    animations: boolean;
    transitions: boolean;
    laserPointer: boolean;
    cursorVisible: boolean;
    annotations: boolean;
}
export type RecordingStatus = 'idle' | 'requesting-permissions' | 'ready' | 'countdown' | 'recording' | 'paused' | 'stopping' | 'processing' | 'complete' | 'error';
export interface RecordingState {
    status: RecordingStatus;
    error?: string;
    duration: number;
    currentSlide: number;
    slideTimestamps: SlideTimestamp[];
    blob?: Blob;
    url?: string;
}
export interface SlideTimestamp {
    slideIndex: number;
    time: number;
    title?: string;
}
export interface MediaDevice {
    deviceId: string;
    label: string;
    kind: 'videoinput' | 'audioinput' | 'audiooutput';
}
export interface AvailableDevices {
    cameras: MediaDevice[];
    microphones: MediaDevice[];
    speakers: MediaDevice[];
}
export interface RecordingContextValue {
    state: RecordingState;
    config: RecordingConfig;
    devices: AvailableDevices;
    setConfig: (config: Partial<RecordingConfig>) => void;
    setWebcamConfig: (config: Partial<WebcamConfig>) => void;
    setAudioConfig: (config: Partial<AudioConfig>) => void;
    requestPermissions: () => Promise<boolean>;
    startRecording: (countdownSeconds?: number) => Promise<void>;
    pauseRecording: () => void;
    resumeRecording: () => void;
    stopRecording: () => Promise<Blob>;
    cancelRecording: () => void;
    markSlideChange: (slideIndex: number, title?: string) => void;
    webcamStream: MediaStream | null;
    downloadRecording: (filename?: string) => void;
    exportTimestamps: () => SlideTimestamp[];
}
export interface RecordingProviderProps {
    children: React.ReactNode;
    slideContainer?: HTMLElement | null;
    initialConfig?: Partial<RecordingConfig>;
}
export declare function RecordingProvider({ children, slideContainer, initialConfig, }: RecordingProviderProps): React.ReactElement;
export declare function useRecording(): RecordingContextValue;
export declare function useRecordingStatus(): RecordingStatus;
export declare function useRecordingDuration(): number;
export interface WebcamPreviewProps {
    className?: string;
    style?: React.CSSProperties;
}
export declare function WebcamPreview({ className, style }: WebcamPreviewProps): React.ReactElement | null;
export interface RecordingControlsProps {
    className?: string;
    style?: React.CSSProperties;
    onComplete?: (blob: Blob) => void;
}
export declare function RecordingControls({ className, style, onComplete, }: RecordingControlsProps): React.ReactElement;
export interface RecordingIndicatorProps {
    className?: string;
    style?: React.CSSProperties;
}
export declare function RecordingIndicator({ className, style, }: RecordingIndicatorProps): React.ReactElement | null;
declare const _default: {
    RecordingProvider: typeof RecordingProvider;
    useRecording: typeof useRecording;
    useRecordingStatus: typeof useRecordingStatus;
    useRecordingDuration: typeof useRecordingDuration;
    WebcamPreview: typeof WebcamPreview;
    RecordingControls: typeof RecordingControls;
    RecordingIndicator: typeof RecordingIndicator;
};
export default _default;
//# sourceMappingURL=recordingMode.d.ts.map