@vidtreo/recorder 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,964 @@
+export declare const FILE_SIZE_UNITS: readonly ["Bytes", "KB", "MB", "GB"];
+export declare const FILE_SIZE_BASE = 1024;
+export declare const TIMESTAMP_REGEX: RegExp;
+export declare const DEFAULT_COUNTDOWN_DURATION = 5000;
+export declare const AUDIO_LEVEL_INTERVAL = 100;
+export declare const AUDIO_LEVEL_BARS = 15;
+export declare const CLEANUP_INTERVAL: number;
+export declare const DEFAULT_BACKEND_URL = "https://api.vidtreo.com";
+
+import { DeviceManager as CoreDeviceManager } from "../../core/device/device-manager";
+export declare class DeviceManager extends CoreDeviceManager {
+    updateDeviceSelects(shadowRoot: ShadowRoot): void;
+}
+
+export declare class AudioLevelVisualizer {
+    private barsContainer;
+    initializeBars(shadowRoot: ShadowRoot): void;
+    updateBars(level: number, isMuted: boolean): void;
+    private queryElement;
+    private createBar;
+    private updateBar;
+    private calculateThreshold;
+    private setBarHeight;
+    private setBarStyle;
+}
+
+import type { RecordingState, SourceType, UploadResult } from "../../core/types/recorder-types";
+export declare class UIStateManager {
+    private readonly shadowRoot;
+    constructor(shadowRoot: ShadowRoot);
+    private queryElement;
+    private setText;
+    private toggleClass;
+    private setStyle;
+    private setDisplay;
+    private setDisabled;
+    showError(message: string): void;
+    hideError(): void;
+    showProgress(): void;
+    hideProgress(): void;
+    updateProgress(percentage: number, text: string): void;
+    updateRecordingTimer(formatted: string): void;
+    updateMuteState(muted: boolean, onAudioLevelUpdate: (level: number, isMuted: boolean) => void, audioLevel: number): void;
+    updatePauseState(isPaused: boolean): void;
+    updateCountdownOverlay(recordingState: RecordingState, countdownRemaining: number): void;
+    showSourceTransition(message: string): void;
+    hideSourceTransition(): void;
+    handleStreamStart(recordingState: RecordingState, onInitializeAudioBars: () => void): void;
+    handleStreamStop(onStopAudioTracking: () => void): void;
+    handleRecordingStart(isPaused: boolean): void;
+    updateRecordingControlsAfterStop(): void;
+    updateSwitchButtonText(currentSourceType: SourceType): void;
+    toggleSettings(currentState: boolean): boolean;
+    showUploadProgress(): void;
+    updateUploadProgress(progress: number): void;
+    hideUploadProgress(): void;
+    showUploadSuccess(result: UploadResult): void;
+    showUploadError(message: string): void;
+    clearUploadStatus(): void;
+    updateVideoPreview(stream: MediaStream | null): void;
+    getShadowRoot(): ShadowRoot;
+}
+
+export declare function getTemplate(isMuted: boolean, currentSourceType?: "camera" | "screen"): string;
+
+export type ConfigFromAttributes = {
+    apiKey: string | null;
+    backendUrl: string;
+    countdownDuration?: number;
+    maxRecordingTime?: number;
+    userMetadata?: Record<string, unknown>;
+};
+export declare function normalizeBackendUrl(url: string | null | undefined): string;
+export declare function buildConfigFromAttributes(element: HTMLElement, userMetadata: Record<string, unknown>): ConfigFromAttributes;
+
+export declare function queryElement<T extends HTMLElement>(shadowRoot: ShadowRoot, selector: string): T;
+
+export declare const STYLES: string;
+
+import { RecorderController } from "../core/recorder/recorder-controller";
+export declare class VidtreoRecorder extends HTMLElement {
+    static observedAttributes: string[];
+    private readonly controller;
+    private readonly uiStateManager;
+    private readonly deviceManager;
+    private readonly audioLevelVisualizer;
+    private recordedBlob;
+    private processedBlob;
+    private isProcessing;
+    private isMuted;
+    private showSettings;
+    private readonly userMetadata;
+    constructor();
+    connectedCallback(): Promise<void>;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+    disconnectedCallback(): void;
+    private get shadow();
+    checkPendingUploads(): Promise<void>;
+    startCamera(): Promise<void>;
+    startRecording(): Promise<void>;
+    stopRecording(): Promise<void>;
+    pauseRecording(): void;
+    resumeRecording(): void;
+    processVideo(): Promise<void>;
+    downloadVideo(): void;
+    playVideo(): void;
+    toggleMute(): void;
+    toggleSource(): Promise<void>;
+    toggleSettings(): void;
+    handleCameraChange(value: string): Promise<void>;
+    handleMicChange(value: string): Promise<void>;
+    handleStateChange(state: string, previousState: string): void;
+    handleStreamStart(stream: MediaStream): void;
+    handleStreamStop(): void;
+    handleRecordingStart(): void;
+    handleRecordingStop(blob: Blob): Promise<void>;
+    updateRecordingTimer(formatted: string): void;
+    updateMuteState(muted: boolean): void;
+    updateVideoPreview(stream: MediaStream): void;
+    showError(message: string): void;
+    extractErrorMessage(error: unknown): string;
+    getStreamManager(): import("..").CameraStreamManager;
+    getShadowRoot(): ShadowRoot;
+    getController(): RecorderController;
+    getUIStateManager(): UIStateManager;
+    getDeviceManager(): DeviceManager;
+    getAudioLevelVisualizer(): AudioLevelVisualizer;
+    getRecordedBlob(): Blob | null;
+    setRecordedBlob(blob: Blob | null): void;
+    getProcessedBlob(): Blob | null;
+    setProcessedBlob(blob: Blob | null): void;
+    getIsProcessing(): boolean;
+    setIsProcessing(value: boolean): void;
+    getIsMuted(): boolean;
+    setIsMuted(value: boolean): void;
+    getShowSettings(): boolean;
+    setShowSettings(value: boolean): void;
+    getUserMetadata(): Record<string, unknown>;
+    getNormalizedBackendUrl(url: string | null | undefined): string;
+}
+
+export declare function downloadVideo(blob: Blob): void;
+export declare function playVideo(blob: Blob): void;
+
+import type { VidtreoRecorder } from "../vidtreo-recorder.wc";
+export declare function handleStartRecording(component: VidtreoRecorder): Promise<void>;
+export declare function handleStopRecording(component: VidtreoRecorder): Promise<Blob>;
+export declare function handlePauseRecording(component: VidtreoRecorder): void;
+export declare function handleResumeRecording(component: VidtreoRecorder): void;
+export declare function handleProcessVideo(component: VidtreoRecorder): Promise<void>;
+
+import type { SourceType } from "../../core/types/recorder-types";
+export declare function updatePreviewAfterSourceSwitch(videoPreview: HTMLVideoElement, stream: MediaStream, sourceType: SourceType): Promise<void>;
+export declare function updatePreviewAfterDeviceSwitch(videoPreview: HTMLVideoElement, stream: MediaStream): Promise<void>;
+
+import type { VidtreoRecorder } from "../vidtreo-recorder.wc";
+export declare function attachEventListeners(component: VidtreoRecorder): void;
+
+import type { RecorderCallbacks } from "../../core/recorder/types";
+import type { VidtreoRecorder } from "../vidtreo-recorder.wc";
+export declare function createRecorderCallbacks(component: VidtreoRecorder): RecorderCallbacks;
+
+import type { VidtreoRecorder } from "../vidtreo-recorder.wc";
+export declare function showPreviewSkeleton(shadowRoot: ShadowRoot, message: string): void;
+export declare function hidePreviewSkeleton(shadowRoot: ShadowRoot): void;
+export declare function handleCameraChange(component: VidtreoRecorder, value: string): Promise<void>;
+export declare function handleMicChange(component: VidtreoRecorder, value: string): Promise<void>;
+
+import type { CameraStreamManager } from "../../core/stream/stream";
+import type { SourceType } from "../../core/types/recorder-types";
+import type { DeviceManager } from "../managers/device-manager";
+import type { UIStateManager } from "../managers/ui-state-manager";
+export declare class SourceSwitchHandler {
+    private currentSourceType;
+    private originalCameraStream;
+    private readonly streamManager;
+    private readonly uiStateManager;
+    private readonly deviceManager;
+    private readonly onShowError;
+    private screenShareTrackEndHandler;
+    constructor(streamManager: CameraStreamManager, uiStateManager: UIStateManager, deviceManager: DeviceManager, onShowError: (message: string) => void);
+    getCurrentSourceType(): SourceType;
+    setCurrentSourceType(type: SourceType): void;
+    getOriginalCameraStream(): MediaStream | null;
+    setOriginalCameraStream(stream: MediaStream | null): void;
+    private stopStreamTracks;
+    switchToScreenCapture(): Promise<MediaStream>;
+    setupScreenShareTrackHandler(newStream: MediaStream, onSwitchToCamera: () => Promise<void>): void;
+    removeScreenShareTrackHandler(stream: MediaStream | null): void;
+    getCameraStream(): Promise<MediaStream>;
+    switchToCamera(): Promise<void>;
+    updatePreviewAfterSourceSwitch(newStream: MediaStream): Promise<void>;
+    toggleSource(): Promise<void>;
+    cleanup(): void;
+    private completePlaySuccess;
+    private handlePlayError;
+    private retryPlay;
+    private completePlayError;
+}
+
+import type { VidtreoRecorder } from "../vidtreo-recorder.wc";
+export declare function setupEventListeners(component: VidtreoRecorder): void;
+
+export type RecordingState = "idle" | "countdown" | "recording";
+export type SourceType = "camera" | "screen";
+export type AvailableDevices = {
+    audioinput: MediaDeviceInfo[];
+    videoinput: MediaDeviceInfo[];
+};
+export type UploadResult = {
+    videoId: string;
+    uploadUrl: string;
+};
+
+import type { TranscodeConfig } from "../processor/types";
+export declare class ConfigManager {
+    private configService;
+    private currentConfig;
+    private configFetchPromise;
+    initialize(apiKey: string | null, backendUrl: string | null): void;
+    fetchConfig(): Promise<void>;
+    getConfig(): Promise<TranscodeConfig>;
+    clearCache(): void;
+}
+
+import type { TranscodeConfig } from "../processor/types";
+export declare const DEFAULT_TRANSCODE_CONFIG: Readonly<TranscodeConfig>;
+
+import type { TranscodeConfig } from "../processor/types";
+export type BackendPreset = "sd" | "hd" | "fhd" | "4k";
+export type BackendConfigResponse = {
+    presetEncoding: BackendPreset;
+    max_width: number;
+    max_height: number;
+};
+export declare function mapPresetToConfig(preset: BackendPreset, maxWidth: number, maxHeight: number): TranscodeConfig;
+
+import type { TranscodeConfig } from "../processor/types";
+export type ConfigServiceOptions = {
+    apiKey: string;
+    backendUrl: string;
+    cacheTimeout?: number;
+};
+export declare class ConfigService {
+    private cachedConfig;
+    private cacheTimestamp;
+    private readonly cacheTimeout;
+    private fetchPromise;
+    private readonly options;
+    constructor(options: ConfigServiceOptions);
+    fetchConfig(): Promise<TranscodeConfig>;
+    clearCache(): void;
+    getCurrentConfig(): TranscodeConfig;
+    private fetchConfigFromBackend;
+}
+
+import { StreamProcessor } from "../processor/stream-processor";
+import type { CameraStreamManager } from "../stream/stream";
+import type { RecordingState } from "../types/recorder-types";
+export declare class RecordingManager {
+    private recordingState;
+    private countdownDuration;
+    private countdownRemaining;
+    private countdownTimeoutId;
+    private countdownIntervalId;
+    private countdownStartTime;
+    private isPaused;
+    private maxRecordingTime;
+    private maxTimeTimer;
+    private recordingSeconds;
+    private recordingIntervalId;
+    private pauseStartTime;
+    private totalPausedTime;
+    private readonly streamManager;
+    private readonly callbacks;
+    private streamProcessor;
+    private originalCameraStream;
+    constructor(streamManager: CameraStreamManager, callbacks: RecordingCallbacks);
+    setCountdownDuration(duration: number): void;
+    setMaxRecordingTime(maxTime: number | null): void;
+    getRecordingState(): RecordingState;
+    isPausedState(): boolean;
+    getRecordingSeconds(): number;
+    getStreamProcessor(): StreamProcessor | null;
+    setOriginalCameraStream(stream: MediaStream | null): void;
+    getOriginalCameraStream(): MediaStream | null;
+    startRecording(): Promise<void>;
+    private startCountdown;
+    private doStartRecording;
+    stopRecording(): Promise<Blob>;
+    pauseRecording(): void;
+    resumeRecording(): void;
+    cancelCountdown(): void;
+    cleanup(): void;
+    private resetRecordingState;
+    private resetPauseState;
+    private updatePausedDuration;
+    private startRecordingTimer;
+    private clearTimer;
+    private handleError;
+}
+
+import type { TranscodeConfig } from "../processor/types";
+import type { RecordingState } from "../types/recorder-types";
+export type RecordingCallbacks = {
+    onStateChange: (state: RecordingState) => void;
+    onCountdownUpdate: (state: RecordingState, remaining: number) => void;
+    onTimerUpdate: (formatted: string) => void;
+    onError: (error: Error) => void;
+    onRecordingComplete: (blob: Blob) => void;
+    onClearUploadStatus: () => void;
+    onStopAudioTracking: () => void;
+    onGetConfig: () => Promise<TranscodeConfig>;
+};
+
+export type CameraConstraints = {
+    width?: number | {
+        ideal?: number;
+        min?: number;
+        max?: number;
+    };
+    height?: number | {
+        ideal?: number;
+        min?: number;
+        max?: number;
+    };
+    frameRate?: number | {
+        ideal?: number;
+        min?: number;
+        max?: number;
+    };
+};
+export type StreamConfig = {
+    video: boolean | CameraConstraints;
+    audio: boolean | MediaTrackConstraints;
+};
+export type RecordingOptions = {
+    mimeType?: string;
+    videoBitsPerSecond?: number;
+    audioBitsPerSecond?: number;
+    bitsPerSecond?: number;
+};
+export type StreamState = "idle" | "starting" | "active" | "recording" | "stopping" | "error";
+export type StreamEventMap = {
+    statechange: {
+        state: StreamState;
+        previousState: StreamState;
+    };
+    streamstart: {
+        stream: MediaStream;
+    };
+    streamstop: undefined;
+    recordingstart: {
+        recorder: MediaRecorder | null;
+    };
+    recordingstop: {
+        blob: Blob;
+        mimeType: string;
+    };
+    recordingdata: {
+        data: Blob;
+    };
+    error: {
+        error: Error;
+    };
+    recordingtimeupdate: {
+        elapsed: number;
+        formatted: string;
+    };
+    recordingbufferupdate: {
+        size: number;
+        formatted: string;
+    };
+    audiomutetoggle: {
+        muted: boolean;
+    };
+    videosourcechange: {
+        stream: MediaStream;
+    };
+};
+export type StreamEventListener<T extends keyof StreamEventMap> = (data: StreamEventMap[T]) => void;
+
+export declare const DEFAULT_CAMERA_CONSTRAINTS: Readonly<CameraConstraints>;
+export declare const DEFAULT_STREAM_CONFIG: Readonly<StreamConfig>;
+export declare const DEFAULT_RECORDING_OPTIONS: Readonly<RecordingOptions>;
+
+import type { SourceType } from "../types/recorder-types";
+export type SourceSwitchCallbacks = {
+    onSourceChange?: (sourceType: SourceType) => void;
+    onPreviewUpdate?: (stream: MediaStream) => Promise<void>;
+    onError?: (error: Error) => void;
+    onTransitionStart?: (message: string) => void;
+    onTransitionEnd?: () => void;
+    getSelectedCameraDeviceId?: () => string | null;
+    getSelectedMicDeviceId?: () => string | null;
+};
+export declare class SourceSwitchManager {
+    private currentSourceType;
+    private originalCameraStream;
+    private originalCameraConstraints;
+    private screenShareStream;
+    private screenShareTrackEndHandler;
+    private readonly streamManager;
+    private callbacks;
+    constructor(streamManager: CameraStreamManager, callbacks?: SourceSwitchCallbacks);
+    getCurrentSourceType(): SourceType;
+    getOriginalCameraStream(): MediaStream | null;
+    private stopStreamTracks;
+    private isTrackLive;
+    private areTracksLive;
+    private storeOriginalCameraConstraints;
+    private storeOriginalCameraStream;
+    private createError;
+    private waitForTracksToEnd;
+    switchToScreenCapture(): Promise<MediaStream>;
+    private setupScreenShareTrackHandler;
+    removeScreenShareTrackHandler(stream: MediaStream | null): void;
+    private canReuseOriginalStream;
+    private canReuseManagerStream;
+    private buildVideoConstraints;
+    private buildAudioConstraints;
+    private createNewCameraStreamForRecording;
+    getCameraStream(): Promise<MediaStream>;
+    switchToCamera(): Promise<void>;
+    private notifyTransitionStart;
+    private notifyTransitionEnd;
+    private handleScreenShareStop;
+    private applyCameraStream;
+    toggleSource(): Promise<void>;
+    private switchToScreen;
+    private handleToggleError;
+    handleRecordingStop(): Promise<void>;
+    cleanup(): void;
+    setCallbacks(callbacks: SourceSwitchCallbacks): void;
+}
+
+import type { StreamProcessor } from "../processor/stream-processor";
+import type { TranscodeConfig } from "../processor/types";
+export declare class CameraStreamManager {
+    private mediaStream;
+    private mediaRecorder;
+    private recordedChunks;
+    private recordedMimeType;
+    private state;
+    private recordingStartTime;
+    private recordingTimer;
+    private pauseStartTime;
+    private totalPausedTime;
+    private readonly eventListeners;
+    private readonly streamConfig;
+    private readonly recordingOptions;
+    private streamProcessor;
+    private bufferSizeUpdateInterval;
+    private selectedAudioDeviceId;
+    private selectedVideoDeviceId;
+    constructor(streamConfig?: Partial<StreamConfig>, recordingOptions?: Partial<RecordingOptions>);
+    getState(): StreamState;
+    getStream(): MediaStream | null;
+    getAudioStreamForAnalysis(): MediaStream | null;
+    getRecorder(): MediaRecorder | null;
+    isRecording(): boolean;
+    isActive(): boolean;
+    on<T extends keyof StreamEventMap>(event: T, listener: StreamEventListener<T>): () => void;
+    off<T extends keyof StreamEventMap>(event: T, listener: StreamEventListener<T>): void;
+    once<T extends keyof StreamEventMap>(event: T, listener: StreamEventListener<T>): () => void;
+    private emit;
+    private setState;
+    setAudioDevice(deviceId: string | null): void;
+    setVideoDevice(deviceId: string | null): void;
+    getAudioDevice(): string | null;
+    getVideoDevice(): string | null;
+    getAvailableDevices(): Promise<{
+        audioinput: MediaDeviceInfo[];
+        videoinput: MediaDeviceInfo[];
+    }>;
+    private buildVideoConstraints;
+    private buildAudioConstraints;
+    startStream(): Promise<MediaStream>;
+    stopStream(): void;
+    private stopStreamTracks;
+    private isTrackLive;
+    private tryReplaceTrack;
+    private recreateStreamWithNewTrack;
+    switchVideoDevice(deviceId: string | null): Promise<MediaStream>;
+    switchAudioDevice(deviceId: string | null): Promise<MediaStream>;
+    startRecordingWithMediaRecorder(): void;
+    stopRecordingWithMediaRecorder(): void;
+    startRecording(processor: StreamProcessor, config: TranscodeConfig): Promise<void>;
+    stopRecording(): Promise<Blob>;
+    pauseRecording(): void;
+    resumeRecording(): void;
+    toggleMute(): void;
+    private setAudioTracksEnabled;
+    muteAudio(): void;
+    unmuteAudio(): void;
+    isMuted(): boolean;
+    switchVideoSource(newStream: MediaStream): Promise<void>;
+    setMediaStream(stream: MediaStream): void;
+    getCurrentVideoSource(): MediaStream;
+    private formatTimeElapsed;
+    private startRecordingTimer;
+    private clearRecordingTimer;
+    private clearBufferSizeInterval;
+    private resetRecordingState;
+    private resetPauseState;
+    getRecordedBlob(): Blob;
+    destroy(): void;
+}
+
+export declare class CanvasRenderer {
+    private readonly canvasContext;
+    constructor(canvasContext: OffscreenCanvasRenderingContext2D);
+    clear(): void;
+    drawFrame(videoElement: HTMLVideoElement): void;
+    getContext(): OffscreenCanvasRenderingContext2D;
+}
+
+export declare class StreamProcessor {
+    private readonly outputManager;
+    private canvasSource;
+    private offscreenCanvas;
+    private readonly videoElementManager;
+    private canvasRenderer;
+    private readonly frameCapturer;
+    private readonly audioTrackManager;
+    private currentVideoStream;
+    private onSourceChange?;
+    constructor();
+    startProcessing(stream: MediaStream, config: TranscodeConfig): Promise<void>;
+    pause(): void;
+    resume(): void;
+    isPausedState(): boolean;
+    finalize(): Promise<StreamProcessorResult>;
+    toggleMute(): void;
+    isMutedState(): boolean;
+    getClonedAudioTrack(): MediaStreamTrack | null;
+    getAudioStreamForAnalysis(): MediaStream | null;
+    switchVideoSource(newStream: MediaStream): Promise<void>;
+    getCurrentVideoSource(): MediaStream | null;
+    getBufferSize(): number;
+    setOnMuteStateChange(callback: (muted: boolean) => void): void;
+    setOnSourceChange(callback: (stream: MediaStream) => void): void;
+    cancel(): Promise<void>;
+}
+
+export type TranscodeConfig = {
+    format: "mp4";
+    fps: number;
+    width: number;
+    height: number;
+    bitrate: number;
+    audioCodec: "aac";
+    preset: "medium";
+    packetCount: number;
+    audioBitrate?: number;
+};
+export type TranscodeInput = Blob | File | string;
+export type TranscodeResult = {
+    buffer: ArrayBuffer;
+    blob: Blob;
+};
+export type StreamProcessorResult = {
+    blob: Blob;
+    totalSize: number;
+};
+export type StreamProcessorOptions = Record<string, never>;
+
+import { Output } from "mediabunny";
+export declare class OutputManager {
+    private output;
+    private readonly chunks;
+    private totalSize;
+    create(): Output;
+    getOutput(): Output;
+    getChunks(): Array<{
+        data: Uint8Array;
+        position: number;
+    }>;
+    finalize(): Promise<StreamProcessorResult>;
+    cancel(): Promise<void>;
+    getTotalSize(): number;
+}
+
+export declare function transcodeVideo(input: TranscodeInput, config?: Partial<TranscodeConfig>, onProgress?: (progress: number) => void): Promise<TranscodeResult>;
+
+export declare class VideoElementManager {
+    private videoElement;
+    private isActive;
+    private isIntentionallyPaused;
+    create(stream: MediaStream): HTMLVideoElement;
+    waitForReady(): Promise<void>;
+    switchSource(newStream: MediaStream): Promise<void>;
+    getElement(): HTMLVideoElement | null;
+    setActive(active: boolean): void;
+    pause(): void;
+    resume(): void;
+    cleanup(): void;
+    private waitForVideoReady;
+}
+
+import type { CanvasSource } from "mediabunny";
+export declare class FrameCapturer {
+    private timeoutId;
+    private isActive;
+    private isPaused;
+    private frameCount;
+    private lastFrameTimestamp;
+    private currentFrameRate;
+    private canvasSource;
+    private canvasRenderer;
+    private videoElement;
+    private pendingFrameAdd;
+    start(canvasSource: CanvasSource, canvasRenderer: CanvasRenderer, videoElement: HTMLVideoElement, frameRate: number): void;
+    pause(): void;
+    resume(): void;
+    isPausedState(): boolean;
+    getLastFrameTimestamp(): number;
+    waitForPendingFrames(): Promise<void>;
+    stop(): void;
+    private captureFrame;
+    private canCaptureFrame;
+    private isVideoReady;
+    private renderFrame;
+    private addFrameToSource;
+    private scheduleNextFrame;
+}
+
+import { AudioSampleSource } from "mediabunny";
+export declare class AudioTrackManager {
+    private originalAudioTrack;
+    private audioContext;
+    private audioWorkletNode;
+    private mediaStreamSource;
+    private gainNode;
+    private audioSource;
+    private lastAudioTimestamp;
+    private isMuted;
+    private isPaused;
+    private onMuteStateChange?;
+    setupAudioTrack(stream: MediaStream, config: TranscodeConfig): Promise<AudioSampleSource | null>;
+    toggleMute(): void;
+    isMutedState(): boolean;
+    pause(): void;
+    resume(): AudioSampleSource | null;
+    isPausedState(): boolean;
+    getClonedAudioTrack(): MediaStreamTrack | null;
+    getAudioSource(): AudioSampleSource | null;
+    getAudioStreamForAnalysis(): MediaStream | null;
+    getLastAudioTimestamp(): number;
+    setOnMuteStateChange(callback: (muted: boolean) => void): void;
+    cleanup(): void;
+}
+
+export declare function calculateBarColor(position: number): string;
+
+export declare const FILE_SIZE_UNITS: readonly ["Bytes", "KB", "MB", "GB"];
+export declare const FILE_SIZE_BASE = 1024;
+export declare function formatFileSize(bytes: number): string;
+export declare function formatTime(totalSeconds: number): string;
+
+export declare function extractErrorMessage(error: unknown): string;
+
+export type PendingUpload = {
+    id: string;
+    blob: Blob;
+    apiKey: string;
+    backendUrl: string;
+    filename: string;
+    duration?: number;
+    metadata?: Record<string, unknown>;
+    userMetadata?: Record<string, unknown>;
+    status: "pending" | "uploading" | "failed" | "completed";
+    retryCount: number;
+    lastError?: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export declare class VideoStorageService {
+    private db;
+    init(): Promise<void>;
+    isInitialized(): boolean;
+    savePendingUpload(upload: Omit<PendingUpload, "id" | "createdAt" | "updatedAt" | "status" | "retryCount">): Promise<string>;
+    getPendingUploads(status?: PendingUpload["status"]): Promise<PendingUpload[]>;
+    updateUploadStatus(id: string, updates: Partial<PendingUpload>): Promise<void>;
+    deleteUpload(id: string): Promise<void>;
+    cleanupPermanentlyFailedUploads(retentionHours?: number): Promise<number>;
+    getTotalStorageSize(): Promise<number>;
+    private generateUploadId;
+    private executeTransaction;
+}
+
+import type { UploadResult } from "../types/recorder-types";
+export type UploadCallbacks = {
+    onUploadProgress: (id: string, progress: number) => void;
+    onUploadComplete: (id: string, result: UploadResult) => void;
+    onUploadError: (id: string, error: Error) => void;
+};
+
+import { UploadQueueManager } from "../upload/upload-queue-manager";
+import type { VideoUploadService } from "../upload/video-upload-service";
+export declare class StorageManager {
+    private storageService;
+    private uploadQueueManager;
+    private cleanupIntervalId;
+    initialize(uploadService: VideoUploadService | null, callbacks: UploadCallbacks, onCleanupError: (error: string) => void): Promise<void>;
+    checkPendingUploads(): Promise<{
+        pending: number;
+        uploading: number;
+    }>;
+    performCleanup(): Promise<void>;
+    getUploadQueueManager(): UploadQueueManager | null;
+    getStorageService(): VideoStorageService | null;
+    destroy(): void;
+}
+
+export type StorageQuota = {
+    usage: number;
+    quota: number;
+    available: number;
+    percentage: number;
+};
+export declare class QuotaManager {
+    getQuota(): Promise<StorageQuota>;
+    hasSpaceFor(sizeInBytes: number): Promise<boolean>;
+    requestPersistentStorage(): Promise<boolean>;
+    isPersistent(): Promise<boolean>;
+    formatBytes(bytes: number): string;
+    shouldWarn(threshold?: number): Promise<boolean>;
+    isCritical(threshold?: number): Promise<boolean>;
+    private checkThreshold;
+}
+
+export type AudioLevelCallbacks = {
+    onLevelUpdate: (level: number, isMuted: boolean) => void;
+};
+
+export declare class AudioLevelAnalyzer {
+    private audioContext;
+    private analyser;
+    private audioLevelIntervalId;
+    private audioLevel;
+    private getMutedState;
+    private currentStream;
+    startTracking(stream: MediaStream, callbacks: AudioLevelCallbacks, getMutedState?: () => boolean): void;
+    stopTracking(): void;
+    getAudioLevel(): number;
+    private getAudioContextClass;
+    private calculateAudioLevel;
+    private checkMutedState;
+}
+
+import type { AudioLevelCallbacks } from "../audio/types";
+import type { DeviceCallbacks } from "../device/types";
+import type { RecordingCallbacks } from "../recording/types";
+import type { UploadCallbacks as StorageUploadCallbacks } from "../storage/types";
+import type { SourceType } from "../types/recorder-types";
+import type { UploadCallbacks } from "../upload/types";
+export type RecorderConfig = {
+    apiKey?: string | null;
+    backendUrl?: string | null;
+    countdownDuration?: number;
+    maxRecordingTime?: number | null;
+    userMetadata?: Record<string, unknown>;
+};
+export type RecorderCallbacks = {
+    recording?: RecordingCallbacks;
+    audioLevel?: AudioLevelCallbacks;
+    device?: DeviceCallbacks;
+    upload?: UploadCallbacks;
+    storage?: StorageUploadCallbacks;
+    sourceSwitch?: {
+        onSourceChange?: (sourceType: SourceType) => void;
+        onPreviewUpdate?: (stream: MediaStream) => Promise<void>;
+        onError?: (error: Error) => void;
+        onTransitionStart?: (message: string) => void;
+        onTransitionEnd?: () => void;
+    };
+    stream?: {
+        onStreamStart?: (stream: MediaStream) => void;
+        onStreamStop?: () => void;
+        onError?: (error: Error) => void;
+    };
+    onStorageCleanupError?: (error: string) => void;
+};
+
+import type { AudioLevelAnalyzer } from "../audio/audio-level-analyzer";
+import type { ConfigManager } from "../config/config-manager";
+import type { DeviceManager } from "../device/device-manager";
+import type { RecordingCallbacks } from "../recording/types";
+import type { SourceSwitchCallbacks } from "../stream/source-switch";
+export declare function createRecordingCallbacks(callbacks: RecorderCallbacks, audioLevelAnalyzer: AudioLevelAnalyzer, configManager: ConfigManager): RecordingCallbacks;
+export declare function createSourceSwitchCallbacks(callbacks: RecorderCallbacks, deviceManager: DeviceManager): SourceSwitchCallbacks;
+
+import type { AudioLevelCallbacks } from "../audio/types";
+import { DeviceManager } from "../device/device-manager";
+import { CameraStreamManager } from "../stream/stream";
+import type { SourceType } from "../types/recorder-types";
+export declare class RecorderController {
+    private readonly streamManager;
+    private readonly configManager;
+    private readonly storageManager;
+    private readonly deviceManager;
+    private readonly audioLevelAnalyzer;
+    private readonly uploadManager;
+    private readonly recordingManager;
+    private readonly sourceSwitchManager;
+    private readonly uploadService;
+    private readonly muteStateManager;
+    private isInitialized;
+    constructor(callbacks?: RecorderCallbacks);
+    initialize(config: RecorderConfig): Promise<void>;
+    startStream(): Promise<void>;
+    stopStream(): Promise<void>;
+    switchVideoDevice(deviceId: string | null): Promise<MediaStream>;
+    switchAudioDevice(deviceId: string | null): Promise<MediaStream>;
+    startRecording(): Promise<void>;
+    stopRecording(): Promise<Blob>;
+    pauseRecording(): void;
+    resumeRecording(): void;
+    switchSource(_sourceType: SourceType): Promise<void>;
+    setCameraDevice(deviceId: string | null): void;
+    setMicDevice(deviceId: string | null): void;
+    getAvailableDevices(): Promise<import("../..").AvailableDevices>;
+    muteAudio(): void;
+    unmuteAudio(): void;
+    toggleMute(): void;
+    getIsMuted(): boolean;
+    startAudioLevelTracking(stream: MediaStream, callbacks?: AudioLevelCallbacks): Promise<void>;
+    stopAudioLevelTracking(): void;
+    getAudioLevel(): number;
+    uploadVideo(blob: Blob, apiKey: string, backendUrl: string, metadata: Record<string, unknown>): Promise<void>;
+    getStream(): MediaStream | null;
+    getRecordingState(): import("../..").RecordingState;
+    isPaused(): boolean;
+    getCurrentSourceType(): SourceType;
+    getOriginalCameraStream(): MediaStream | null;
+    getStreamManager(): CameraStreamManager;
+    getAudioStreamForAnalysis(): MediaStream | null;
+    getDeviceManager(): DeviceManager;
+    getConfig(): Promise<import("../..").TranscodeConfig>;
+    isRecording(): boolean;
+    isActive(): boolean;
+    cleanup(): void;
+}
+
+import type { CameraStreamManager } from "../stream/stream";
+export declare class MuteStateManager {
+    private isMuted;
+    private readonly streamManager;
+    constructor(streamManager: CameraStreamManager);
+    mute(): void;
+    unmute(): void;
+    toggle(): void;
+    getIsMuted(): boolean;
+    getMutedStateCallback(): () => boolean;
+}
+
+import type { CameraStreamManager } from "../stream/stream";
+import type { AvailableDevices } from "../types/recorder-types";
+export declare class DeviceManager {
+    private readonly streamManager;
+    private readonly callbacks?;
+    private availableDevices;
+    private selectedCameraDeviceId;
+    private selectedMicDeviceId;
+    constructor(streamManager: CameraStreamManager, callbacks?: DeviceCallbacks);
+    getAvailableDevices(): Promise<AvailableDevices>;
+    setCameraDevice(deviceId: string | null): void;
+    setMicDevice(deviceId: string | null): void;
+    getSelectedCameraDeviceId(): string | null;
+    getSelectedMicDeviceId(): string | null;
+    getAvailableDevicesList(): AvailableDevices;
+}
+
+import type { AvailableDevices } from "../types/recorder-types";
+export type DeviceCallbacks = {
+    onDevicesChanged: (devices: AvailableDevices) => void;
+    onDeviceSelected: (type: "camera" | "mic", deviceId: string | null) => void;
+};
+
+import type { UploadResult } from "../types/recorder-types";
+export declare class UploadManager {
+    private readonly callbacks;
+    private uploadQueueManager;
+    constructor(callbacks: UploadCallbacks);
+    setUploadQueueManager(uploadQueueManager: UploadQueueManager | null): void;
+    uploadVideo(blob: Blob, apiKey: string, backendUrl: string, userMetadata: Record<string, unknown>): Promise<void>;
+    updateProgress(progress: number): void;
+    showSuccess(result: UploadResult): void;
+    showError(message: string): void;
+    clearStatus(): void;
+}
+
+import type { PendingUpload, VideoStorageService } from "../storage/video-storage";
+type UploadCallbacks = {
+    onUploadProgress?: (id: string, progress: number) => void;
+    onUploadComplete?: (id: string, result: VideoUploadResult) => void;
+    onUploadError?: (id: string, error: Error) => void;
+};
+export declare class UploadQueueManager {
+    private readonly storageService;
+    private readonly uploadService;
+    private readonly processingIntervalId;
+    private readonly networkOnlineHandler;
+    private isProcessing;
+    private retryTimeoutId;
+    private callbacks;
+    constructor(storageService: VideoStorageService, uploadService: VideoUploadService);
+    destroy(): void;
+    setCallbacks(callbacks: UploadCallbacks): void;
+    queueUpload(upload: Omit<PendingUpload, "id" | "createdAt" | "updatedAt" | "status" | "retryCount">): Promise<string>;
+    processQueue(): Promise<void>;
+    getPendingUploads(): Promise<PendingUpload[]>;
+    getStats(): Promise<{
+        pending: number;
+        uploading: number;
+        failed: number;
+        total: number;
+    }>;
+    private getOldestUpload;
+    private getOldestFailedUpload;
+    private processUpload;
+    private calculateRetryDelay;
+    private scheduleRetry;
+    private clearTimer;
+}
+export {};
+
+export declare function extractVideoDuration(blob: Blob): Promise<number>;
+
+import type { UploadResult } from "../types/recorder-types";
+export type UploadCallbacks = {
+    onProgress: (progress: number) => void;
+    onSuccess: (result: UploadResult) => void;
+    onError: (error: Error) => void;
+    onClearStatus: () => void;
+};
+
+export type VideoUploadOptions = {
+    apiKey: string;
+    backendUrl: string;
+    filename?: string;
+    metadata?: Record<string, unknown>;
+    userMetadata?: Record<string, unknown>;
+    duration?: number;
+    onProgress?: (progress: number) => void;
+};
+export type VideoUploadInitResponse = {
+    videoId: string;
+    uploadUrl: string;
+};
+export type VideoUploadResult = {
+    videoId: string;
+    status: string;
+    uploadUrl: string;
+};
+export declare class VideoUploadService {
+    uploadVideo(blob: Blob, options: VideoUploadOptions): Promise<VideoUploadResult>;
+    private initVideoUpload;
+    private extractErrorFromResponse;
+    private uploadVideoFile;
+    private parseSuccessResponse;
+    private parseErrorResponse;
+}