import { type ChunkStorage, type ChunkRecordResult } from '../lib/chunk-storage';
/** Storage strategy pour la track audio quand `recordAudioSeparately=true`. */
export type AudioRecordStorage = 'memory' | 'indexeddb' | 'filesystem' | 'server';
/** v2.2+ — Layout du compositeur 3 sources.
 *  - `split`  : écran | flux distant 50/50 + webcam en incrustation.
 *  - `screen` : écran en grand + flux distant & webcam en PiP.
 *  - `sfu`    : flux distant en grand + écran & webcam en PiP.
 *  - `webcam` : webcam en grand + écran & flux distant en PiP. */
export type CompositeLayout = 'split' | 'screen' | 'sfu' | 'webcam';
export interface StartRecordingOptions {
    /** Stratégie de stockage des chunks vidéo.
     *  - `memory` : accumule en RAM, blob final rendu à stopRecording.
     *  - `indexeddb` (défaut) : streame dans IndexedDB — crash-safe, RAM
     *    constante (cf. v1.11.9 — défaut changé pour éviter OOM sur longs records).
     *  - `filesystem` : streame sur le disque via File System Access API
     *    (Chrome/Edge ; non supporté Firefox/Safari).
     *  - `server` : POST chaque chunk à `videoServerUrl`. */
    videoStorage?: ChunkStorage;
    /** URL absolue ou relative qui reçoit les chunks vidéo en POST quand
     *  `videoStorage='server'`. */
    videoServerUrl?: string;
    /** Si true, un second MediaRecorder enregistre l'audio mixé en parallèle
     *  et le résultat est exposé via `stopRecording()` (champ `audio`). */
    recordAudioSeparately?: boolean;
    /** Stratégie de stockage des chunks audio (mêmes options que videoStorage). */
    audioStorage?: AudioRecordStorage;
    /** URL absolue ou relative qui reçoit les chunks audio en POST quand
     *  `audioStorage='server'`. */
    audioServerUrl?: string;
    /** v1.11.10 — Si true, le record vidéo n'embed PAS l'audio (track audio
     *  exclue du combinedStream). Force implicitement `recordAudioSeparately=true`
     *  pour ne pas perdre l'audio.
     *  Use case : "vraie séparation" — montage pro où on veut une vidéo pure
     *  + un fichier audio dédié à mixer/cleaner indépendamment. */
    videoOnly?: boolean;
    /** v2.0+ — Override l'identifiant baseId interne (par défaut auto-généré
     *  `rec-<ts>-<rand>`). Utilisé par `useMultiTakeSession` pour grouper les
     *  takes d'une session sous un préfixe commun (`<sessionId>-take<N>`),
     *  ce qui permet la reconstruction L3 (cross-reload via IndexedDB). */
    baseId?: string;
}
export interface AudioRecordResult {
    storage: AudioRecordStorage;
    /** MIME du record audio (audio/webm;codecs=opus en général). */
    mimeType: string;
    /** Blob audio reconstitué (memory / indexeddb). null pour filesystem / server. */
    blob: Blob | null;
    /** ObjectURL utilisable dans un <audio> ou pour download. null si pas de blob. */
    url: string | null;
    /** IDB session id (key prefix) — uniquement pour `indexeddb`. */
    indexedDbKey?: string;
    /** Handle vers le fichier choisi par l'utilisateur — uniquement pour `filesystem`. */
    fileHandle?: FileSystemFileHandle;
    /** URL serveur où les chunks ont été envoyés — uniquement pour `server`. */
    serverUrl?: string;
    /** Identifiant de session inclus dans X-Session-Id pour `server`. */
    sessionId?: string;
}
export interface RecordingResult {
    /** Blob vidéo. Vide quand `videoStorage` est 'filesystem' ou 'server'
     *  (le record est déjà persisté hors RAM ; voir `video` pour les pointeurs). */
    blob: Blob;
    /** ObjectURL du blob vidéo. Vide quand `videoStorage` est 'filesystem' ou 'server'. */
    url: string;
    /** Détails du stockage vidéo (toujours présent depuis v1.11.9). */
    video?: ChunkRecordResult | null;
    /** Présent uniquement si `recordAudioSeparately=true` était passé à startRecording. */
    audio?: AudioRecordResult | null;
}
export interface StartScreenShareOptions {
    audio?: boolean;
    webcamOverlay?: boolean;
    /** v1.12.0 — Pré-sélectionne une caméra par `deviceId` (cf. enumerateDevices).
     *  Si introuvable (deviceId rotation après reset privacy), fallback sur
     *  `cameraLabelHint` puis sur la caméra par défaut. */
    cameraDeviceId?: string;
    /** v1.12.0 — Pré-sélectionne une caméra par fragment de label (case-insensitive).
     *  Ex : `cameraLabelHint='Logitech'` matche "Logitech C920". Plus robuste que
     *  `cameraDeviceId` car le deviceId peut changer entre sessions. */
    cameraLabelHint?: string;
}
export interface UseCompositeCaptureReturn {
    /** Ref to attach to video element for preview */
    videoRef: React.RefObject<HTMLVideoElement | null>;
    /** Whether screen sharing is active */
    active: boolean;
    /** Whether recording (true while paused too — record session is still open) */
    recording: boolean;
    /** v2.0+ — Whether the recording is paused. Subset of `recording`. */
    paused: boolean;
    /** Recording duration in seconds (frozen while paused) */
    duration: number;
    /** Start screen sharing */
    startScreenShare: (options?: StartScreenShareOptions) => Promise<void>;
    /** Stop screen sharing */
    stopScreenShare: () => void;
    /** Capture current frame as image */
    captureFrame: (format?: string, quality?: number) => string | null;
    /** Start recording screen.
     *  Pass `recordAudioSeparately: true` to also save an audio-only file
     *  via the chosen `audioStorage` strategy. */
    startRecording: (options?: StartRecordingOptions) => Promise<void>;
    /** v2.0+ — Pause the current recording. No-op if not recording or already paused.
     *  Pauses BOTH the video recorder and the optional separate audio recorder.
     *  The canvas-compositor rAF and the WebAudio analyser stay live so the
     *  consumer's preview / VU-meter continues to work during the pause. */
    pauseRecording: () => void;
    /** v2.0+ — Resume a paused recording. No-op if not paused. */
    resumeRecording: () => void;
    /** Stop recording and get the result (video blob + optional audio blob/handle). */
    stopRecording: () => Promise<RecordingResult | null>;
    /** Error */
    error: string | null;
    /** Webcam overlay ref (attach to small video element) */
    webcamRef: React.RefObject<HTMLVideoElement | null>;
    /** Whether webcam overlay is active */
    webcamActive: boolean;
    /** Whether main view is swapped (webcam fullscreen, screen as overlay corner) */
    swapped: boolean;
    /** Toggle main / overlay swap (affects both preview and recorded video) */
    toggleSwap: () => void;
    /** Web Audio AnalyserNode tapping the mixed audio (mic + screen audio).
     *  Available once startScreenShare resolved with audio sources.
     *  Use it for a live VU meter / spectrum visualiser. */
    audioAnalyser: React.RefObject<AnalyserNode | null>;
    /** v1.12.0 — Liste des caméras (videoinput) disponibles.
     *  Vide tant que `refreshCameras()` n'a pas été appelé OU tant que la
     *  permission caméra n'a pas été accordée (les labels seront vides sinon). */
    cameras: MediaDeviceInfo[];
    /** v1.12.0 — `deviceId` de la caméra actuellement utilisée (null si webcam off). */
    selectedCameraId: string | null;
    /** v1.12.0 — Re-énumère les périphériques. Utile après hotplug ou pour
     *  rafraîchir les labels après que la permission a été accordée. */
    refreshCameras: () => Promise<MediaDeviceInfo[]>;
    /** v1.12.0 — Switch live de la caméra sans interrompre l'enregistrement.
     *  - Pendant un record : le track vidéo de la webcam est remplacé in-place
     *    dans le canvas-compositor, le MediaRecorder ne s'arrête pas.
     *  - Hors record : équivaut à un re-getUserMedia.
     *  Ne touche PAS au mic (les tracks audio existantes sont préservées). */
    switchCamera: (deviceId: string) => Promise<void>;
    /** v2.1+ — Stream composite en cours d'enregistrement (canvas screen+webcam
     *  + audio mixé). null hors enregistrement. Sert à publier le take en live
     *  via WHIP (cf. publishSfu) — le take enregistre ET diffuse le même flux. */
    getRecordingStream: () => MediaStream | null;
    /** v2.2+ — true dès qu'un flux distant (SFU/P2P) est branché : le
     *  compositeur bascule alors en layout "split" (écran | distant). */
    hasRemote: boolean;
    /** v2.2+ — Branche un flux distant comme 3ᵉ source du composite, ou le
     *  retire avec `null`. Layout split dès que le flux a une piste vidéo ;
     *  l'audio distant est mixé dans l'enregistrement si le pipeline existe. */
    setRemoteStream: (stream: MediaStream | null) => void;
    /** v2.2+ — Layout courant du compositeur 3 sources. */
    compositeLayout: CompositeLayout;
    /** v2.2+ — Bascule au layout suivant : split → screen → sfu → webcam → split. */
    cycleCompositeLayout: () => void;
}
/**
 * Hook for screen capture and recording, with optional webcam overlay.
 *
 * The hook keeps internal hidden `<video>` elements playing the streams so
 * that recording (canvas-compositing screen + webcam) works regardless of
 * whether the consumer mounted `videoRef` / `webcamRef` in the UI.
 *
 * @example
 * ```tsx
 * const { videoRef, webcamRef, active, startScreenShare, startRecording, stopRecording } = useCompositeCapture()
 *
 * <div style={{ position: 'relative' }}>
 *   <video ref={videoRef} autoPlay playsInline />
 *   <video ref={webcamRef} autoPlay playsInline muted
 *     style={{ position: 'absolute', bottom: 16, right: 16, width: 200, borderRadius: 8 }} />
 * </div>
 * <button onClick={() => startScreenShare({ webcamOverlay: true })}>Share Screen</button>
 * ```
 */
export declare function useCompositeCapture(): UseCompositeCaptureReturn;
//# sourceMappingURL=useCompositeCapture.d.ts.map