import { ConfigurationService } from '../configuration';
import { MediaStreamService } from '../media-stream';
import { ScreenShareService } from '../screen-share';
import { TypedEventEmitter } from '../utils';

export interface RecordingOptions {
    mimeType?: string;
    videoBitsPerSecond?: number;
    audioBitsPerSecond?: number;
    includeAudio?: boolean;
    includeVideo?: boolean;
    includeScreenShare?: boolean;
    format?: 'webm' | 'mp4' | 'mkv';
    quality?: 'low' | 'medium' | 'high' | 'custom';
    autoSave?: boolean;
    saveDirectory?: string;
    maxDuration?: number;
    maxFileSize?: number;
    chunkInterval?: number;
}
export interface RecordingState {
    isRecording: boolean;
    isPaused: boolean;
    duration: number;
    fileSize: number;
    format: string;
    quality: string;
}
interface RecordingEventMap {
    recordingStarted: (state: RecordingState) => void;
    recordingStopped: (blob: Blob) => void;
    recordingPaused: (state: RecordingState) => void;
    recordingResumed: (state: RecordingState) => void;
    recordingData: (data: {
        chunk: Blob;
        totalSize: number;
        duration: number;
    }) => void;
    recordingLimitReached: (data: {
        type: 'duration' | 'fileSize';
        limit: number;
    }) => void;
    recordingError: (error: unknown) => void;
}
export declare class RecordingService extends TypedEventEmitter<RecordingEventMap> {
    private configService;
    private mediaStreamService;
    private screenShareService?;
    private mediaRecorder;
    private recordedChunks;
    private startTime;
    private pausedTime;
    private stream;
    private durationCheckInterval;
    private unsubTrackReplaced;
    private currentOptions;
    private isDestroyed;
    private isStopping;
    constructor(configService: ConfigurationService, mediaStreamService: MediaStreamService, screenShareService?: ScreenShareService);
    startRecording(options?: RecordingOptions): Promise<void>;
    pauseRecording(): void;
    resumeRecording(): void;
    stopRecording(): Promise<Blob>;
    private createRecordingStream;
    private getBestMimeType;
    private setupRecorderEvents;
    destroy(): void;
    private setupTrackReplacementListener;
    private setupDurationLimit;
    private cleanup;
    private getTotalSize;
    private getDuration;
    getState(): RecordingState;
    getSupportedFormats(): string[];
}
export {};