@vidtreo/recorder 0.0.1 → 0.8.1

package/dist/index.d.ts

@@ -1,206 +1,144 @@
-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 type VidtreoRecorderConfig = {
+    apiKey: string;
+    apiUrl: string;
+    enableSourceSwitching?: boolean;
+    enableMute?: boolean;
+    enablePause?: boolean;
+    enableDeviceChange?: boolean;
+    maxRecordingTime?: number;
+    countdownDuration?: number;
+    userMetadata?: Record<string, unknown>;
+    onUploadComplete?: (result: {
+        recordingId: string;
+        uploadUrl: string;
+    }) => void;
+    onUploadProgress?: (progress: number) => void;
+    onUploadError?: (error: Error) => void;
+    onRecordingStart?: () => void;
+    onRecordingStop?: () => void;
+    onError?: (error: Error) => void;
+};
+export type RecordingStartOptions = {
+    video?: boolean | CameraConstraints;
+    audio?: boolean | MediaTrackConstraints;
+};
+export type RecordingStopResult = {
+    recordingId: string;
+    uploadUrl: string;
+    blob: Blob;
+};
+export declare class VidtreoRecorder {
+    private readonly controller;
+    private readonly config;
+    private readonly uploadService;
+    private isInitialized;
+    constructor(config: VidtreoRecorderConfig);
+    initialize(): Promise<void>;
+    startPreview(sourceType?: SourceType): Promise<MediaStream>;
+    startRecording(_options?: RecordingStartOptions, sourceType?: SourceType): Promise<void>;
+    switchSource(sourceType: SourceType): Promise<void>;
+    stopRecording(): Promise<RecordingStopResult>;
+    getAvailableDevices(): Promise<import(".").AvailableDevices>;
+    muteAudio(): void;
+    unmuteAudio(): void;
+    toggleMute(): void;
+    isMuted(): boolean;
+    pauseRecording(): void;
+    resumeRecording(): void;
+    isPaused(): boolean;
+    getRecordingState(): import(".").RecordingState;
+    getStream(): MediaStream | null;
+    cleanup(): void;
+    private ensureInitialized;
 }
 
-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 { UploadResult } from "../types/recorder-types";
+export type UploadCallbacks = {
+    onProgress: (progress: number) => void;
+    onSuccess: (result: UploadResult) => void;
+    onError: (error: Error) => void;
+    onClearStatus: () => void;
+};
 
-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;
+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 getTemplate(isMuted: boolean, currentSourceType?: "camera" | "screen"): string;
-
-export type ConfigFromAttributes = {
-    apiKey: string | null;
+export type VideoUploadOptions = {
+    apiKey: string;
     backendUrl: string;
-    countdownDuration?: number;
-    maxRecordingTime?: number;
+    filename?: string;
+    metadata?: Record<string, unknown>;
     userMetadata?: Record<string, unknown>;
+    duration?: number;
+    onProgress?: (progress: number) => void;
 };
-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 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 parseJsonResponse;
+    private uploadVideoFile;
+    private parseSuccessResponse;
+    private parseErrorResponse;
+    private safeParseJsonFromXhr;
+}
 
-export declare const STYLES: string;
+export declare function extractVideoDuration(blob: Blob): Promise<number>;
 
-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;
+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;
-    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;
+    clearStatus(): void;
 }
 
-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 = {
@@ -212,307 +150,193 @@ export type UploadResult = {
     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;
-}
+export declare function calculateBarColor(position: number): string;
 
-import type { TranscodeConfig } from "../processor/types";
-export declare const DEFAULT_TRANSCODE_CONFIG: Readonly<TranscodeConfig>;
+export declare function extractErrorMessage(error: unknown): string;
 
-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 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 type StorageQuota = {
+    usage: number;
+    quota: number;
+    available: number;
+    percentage: number;
 };
-export declare function mapPresetToConfig(preset: BackendPreset, maxWidth: number, maxHeight: number): TranscodeConfig;
+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;
+}
 
-import type { TranscodeConfig } from "../processor/types";
-export type ConfigServiceOptions = {
+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;
+};
+
+export type PendingUpload = {
+    id: string;
+    blob: Blob;
     apiKey: string;
     backendUrl: string;
-    cacheTimeout?: number;
+    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 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;
+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 { 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 { 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;
 }
 
-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>;
-};
+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;
 
-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;
+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>;
+    enableSourceSwitching?: boolean;
+    enableMute?: boolean;
+    enablePause?: boolean;
+    enableDeviceChange?: boolean;
 };
-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;
+export type RecorderCallbacks = {
+    recording?: Partial<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;
     };
-    videosourcechange: {
-        stream: MediaStream;
+    stream?: {
+        onStreamStart?: (stream: MediaStream) => void;
+        onStreamStop?: () => void;
+        onError?: (error: Error) => void;
     };
+    onStorageCleanupError?: (error: string) => void;
 };
-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 { AudioLevelCallbacks } from "../audio/types";
+import { DeviceManager } from "../device/device-manager";
+import { CameraStreamManager } from "../stream/stream";
 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;
+export declare class RecorderController {
     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;
+    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>;
-    startRecordingWithMediaRecorder(): void;
-    stopRecordingWithMediaRecorder(): void;
-    startRecording(processor: StreamProcessor, config: TranscodeConfig): Promise<void>;
+    startRecording(): Promise<void>;
     stopRecording(): Promise<Blob>;
     pauseRecording(): void;
     resumeRecording(): void;
-    toggleMute(): void;
-    private setAudioTracksEnabled;
+    switchSource(_sourceType: SourceType): Promise<void>;
+    setCameraDevice(deviceId: string | null): void;
+    setMicDevice(deviceId: string | null): void;
+    getAvailableDevices(): Promise<import("../..").AvailableDevices>;
     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;
+    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;
 }
 
-export declare class CanvasRenderer {
-    private readonly canvasContext;
-    constructor(canvasContext: OffscreenCanvasRenderingContext2D);
-    clear(): void;
-    drawFrame(videoElement: HTMLVideoElement): void;
-    getContext(): OffscreenCanvasRenderingContext2D;
+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;
 }
 
 export declare class StreamProcessor {
@@ -543,28 +367,6 @@ export declare class StreamProcessor {
     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;
@@ -581,8 +383,6 @@ export declare class OutputManager {
     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;
@@ -598,6 +398,28 @@ export declare class VideoElementManager {
     private waitForVideoReady;
 }
 
+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 type { CanvasSource } from "mediabunny";
 export declare class FrameCapturer {
     private timeoutId;
@@ -651,314 +473,364 @@ export declare class AudioTrackManager {
     cleanup(): void;
 }
 
-export declare function calculateBarColor(position: number): string;
+export declare class CanvasRenderer {
+    private readonly canvasContext;
+    constructor(canvasContext: OffscreenCanvasRenderingContext2D);
+    clear(): void;
+    drawFrame(videoElement: HTMLVideoElement): void;
+    getContext(): OffscreenCanvasRenderingContext2D;
+}
 
-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 const workletCode = "class AudioCaptureProcessor extends AudioWorkletProcessor {\n  process(inputs, outputs) {\n    const input = inputs[0];\n\n    if (!input?.length) {\n      return true;\n    }\n\n    const bufferLength = input[0].length;\n    const numberOfChannels = input.length;\n    const combinedBuffer = new Float32Array(bufferLength * numberOfChannels);\n\n    for (let channel = 0; channel < numberOfChannels; channel++) {\n      combinedBuffer.set(input[channel], channel * bufferLength);\n    }\n\n    const arrayBuffer = combinedBuffer.buffer.slice(\n      0,\n      combinedBuffer.length * Float32Array.BYTES_PER_ELEMENT\n    );\n\n    this.port.postMessage(\n      {\n        type: \"audioData\",\n        data: arrayBuffer,\n        sampleRate: sampleRate,\n        numberOfChannels,\n        duration: bufferLength / sampleRate,\n        bufferLength: combinedBuffer.length,\n      },\n      [arrayBuffer]\n    );\n\n    if (outputs && outputs[0] && outputs[0].length > 0) {\n      for (let channel = 0; channel < numberOfChannels; channel++) {\n        if (outputs[0][channel] && input[channel]) {\n          outputs[0][channel].set(input[channel]);\n        }\n      }\n    }\n\n    return true;\n  }\n}\n\nregisterProcessor(\"audio-capture-processor\", AudioCaptureProcessor);\n";
 
-export declare function extractErrorMessage(error: unknown): string;
+export declare function transcodeVideo(input: TranscodeInput, config?: Partial<TranscodeConfig>, onProgress?: (progress: number) => void): Promise<TranscodeResult>;
 
-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;
+import type { AvailableDevices } from "../types/recorder-types";
+export type DeviceCallbacks = {
+    onDevicesChanged: (devices: AvailableDevices) => void;
+    onDeviceSelected: (type: "camera" | "mic", deviceId: string | null) => void;
 };
-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 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 { 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;
+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[];
     }>;
-    performCleanup(): Promise<void>;
-    getUploadQueueManager(): UploadQueueManager | null;
-    getStorageService(): VideoStorageService | null;
+    private buildDeviceConstraints;
+    private buildVideoConstraints;
+    private buildAudioConstraints;
+    startStream(): Promise<MediaStream>;
+    stopStream(): void;
+    private stopStreamTracks;
+    private isTrackLive;
+    private tryReplaceTrack;
+    private recreateStreamWithNewTrack;
+    private switchDeviceTrack;
+    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 type StorageQuota = {
-    usage: number;
-    quota: number;
-    available: number;
-    percentage: number;
+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 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 type StreamConfig = {
+    video: boolean | CameraConstraints;
+    audio: boolean | MediaTrackConstraints;
 };
-
-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 RecordingOptions = {
+    mimeType?: string;
+    videoBitsPerSecond?: number;
+    audioBitsPerSecond?: number;
+    bitsPerSecond?: number;
 };
-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;
+export type StreamState = "idle" | "starting" | "active" | "recording" | "stopping" | "error";
+export type StreamEventMap = {
+    statechange: {
+        state: StreamState;
+        previousState: StreamState;
     };
-    stream?: {
-        onStreamStart?: (stream: MediaStream) => void;
-        onStreamStop?: () => void;
-        onError?: (error: Error) => void;
+    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;
     };
-    onStorageCleanupError?: (error: string) => void;
 };
+export type StreamEventListener<T extends keyof StreamEventMap> = (data: StreamEventMap[T]) => 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;
+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 { 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;
+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;
-    getStreamManager(): CameraStreamManager;
-    getAudioStreamForAnalysis(): MediaStream | null;
-    getDeviceManager(): DeviceManager;
-    getConfig(): Promise<import("../..").TranscodeConfig>;
-    isRecording(): boolean;
-    isActive(): boolean;
+    private stopLiveTracks;
+    private stopStreamTracks;
+    private stopStreamVideoTracks;
+    private isTrackLive;
+    private areTracksLive;
+    private storeOriginalCameraConstraints;
+    private storeOriginalCameraStream;
+    private createError;
+    private waitForTracksToEnd;
+    private combineScreenShareWithOriginalAudio;
+    switchToScreenCapture(): Promise<MediaStream | null>;
+    private setupScreenShareTrackHandler;
+    removeScreenShareTrackHandler(stream: MediaStream | null): void;
+    private canReuseStream;
+    private canReuseOriginalStream;
+    private canReuseManagerStream;
+    private getSelectedCameraDeviceId;
+    private getSelectedMicDeviceId;
+    private buildVideoConstraints;
+    private buildAudioConstraints;
+    private validateTrack;
+    private createCameraStreamWithOriginalAudio;
+    private createCameraStreamWithNewAudio;
+    private createNewCameraStreamForRecording;
+    getCameraStream(): Promise<MediaStream>;
+    switchToCamera(): Promise<void>;
+    private notifyTransitionStart;
+    private notifyTransitionEnd;
+    private stopScreenShareStreamTracks;
+    private handleScreenShareStop;
+    private applyCameraStream;
+    toggleSource(): Promise<void>;
+    private switchToScreen;
+    private handleToggleError;
+    handleRecordingStop(): Promise<void>;
     cleanup(): void;
+    setCallbacks(callbacks: SourceSwitchCallbacks): 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;
-}
+export type AudioLevelCallbacks = {
+    onLevelUpdate: (level: number, isMuted: boolean) => void;
+};
 
-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;
+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 { AvailableDevices } from "../types/recorder-types";
-export type DeviceCallbacks = {
-    onDevicesChanged: (devices: AvailableDevices) => void;
-    onDeviceSelected: (type: "camera" | "mic", deviceId: string | null) => void;
+import type { TranscodeConfig } from "../processor/types";
+export type ConfigServiceOptions = {
+    apiKey: string;
+    backendUrl: string;
+    cacheTimeout?: number;
 };
+export declare class ConfigService {
+    private readonly cacheTimeout;
+    private readonly options;
+    private cachedConfig;
+    private cacheTimestamp;
+    private fetchPromise;
+    private constructor();
+    static getInstance(options: ConfigServiceOptions): ConfigService;
+    fetchConfig(): Promise<TranscodeConfig>;
+    clearCache(): void;
+    static clearAllInstances(): void;
+    getCurrentConfig(): TranscodeConfig;
+    private fetchConfigFromBackend;
+}
 
-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 { TranscodeConfig } from "../processor/types";
+export declare class ConfigManager {
+    private configService;
+    private currentConfig;
+    initialize(apiKey: string | null, backendUrl: string | null): void;
+    fetchConfig(): Promise<void>;
+    getConfig(): Promise<TranscodeConfig>;
+    clearCache(): 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;
+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 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 mapPresetToConfig(preset: BackendPreset, maxWidth: number, maxHeight: number): TranscodeConfig;
 
-export declare function extractVideoDuration(blob: Blob): Promise<number>;
+import type { TranscodeConfig } from "../processor/types";
+export declare const DEFAULT_TRANSCODE_CONFIG: Readonly<TranscodeConfig>;
 
-import type { UploadResult } from "../types/recorder-types";
-export type UploadCallbacks = {
-    onProgress: (progress: number) => void;
-    onSuccess: (result: UploadResult) => void;
+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;
-    onClearStatus: () => void;
+    onRecordingComplete: (blob: Blob) => void;
+    onClearUploadStatus: () => void;
+    onStopAudioTracking: () => void;
+    onGetConfig: () => Promise<TranscodeConfig>;
 };
 
-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;
+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;
 }