@360labs/live-transcribe 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2689 @@
+/**
+ * Lightweight EventEmitter implementation for browser and Node.js compatibility
+ */
+declare class EventEmitter<TEvents extends Record<string, (...args: any[]) => void> = Record<string, (...args: any[]) => void>> {
+    private events;
+    /**
+     * Subscribe to an event
+     * @param event - Event name to subscribe to
+     * @param listener - Callback function
+     */
+    on<K extends keyof TEvents>(event: K, listener: TEvents[K]): this;
+    /**
+     * Unsubscribe from an event
+     * @param event - Event name to unsubscribe from
+     * @param listener - Callback function to remove
+     */
+    off<K extends keyof TEvents>(event: K, listener: TEvents[K]): this;
+    /**
+     * Subscribe to an event for one-time notification
+     * @param event - Event name to subscribe to
+     * @param listener - Callback function
+     */
+    once<K extends keyof TEvents>(event: K, listener: TEvents[K]): this;
+    /**
+     * Emit an event to all subscribers
+     * @param event - Event name to emit
+     * @param args - Arguments to pass to listeners
+     */
+    protected emit<K extends keyof TEvents>(event: K, ...args: Parameters<TEvents[K]>): boolean;
+    /**
+     * Remove all listeners for an event, or all listeners if no event specified
+     * @param event - Optional event name
+     */
+    removeAllListeners<K extends keyof TEvents>(event?: K): this;
+    /**
+     * Get the number of listeners for an event
+     * @param event - Event name
+     */
+    listenerCount<K extends keyof TEvents>(event: K): number;
+    /**
+     * Get all event names that have listeners
+     */
+    eventNames(): (keyof TEvents)[];
+}
+
+/**
+ * Represents an individual word in a transcription with timing information
+ */
+interface Word {
+    /** The transcribed word text */
+    text: string;
+    /** Start time in milliseconds */
+    start: number;
+    /** End time in milliseconds */
+    end: number;
+    /** Confidence score (0-1) */
+    confidence?: number;
+}
+/**
+ * Represents a transcription result from the provider
+ */
+interface TranscriptionResult {
+    /** The transcribed text */
+    text: string;
+    /** Whether this is a final or interim result */
+    isFinal: boolean;
+    /** Confidence score (0-1) */
+    confidence?: number;
+    /** When the transcription occurred (Unix timestamp) */
+    timestamp: number;
+    /** Array of individual words with timing information */
+    words?: Word[];
+    /** Speaker identification if supported by provider */
+    speaker?: string;
+    /** Detected or specified language code */
+    language?: string;
+}
+/**
+ * Represents a segment of transcription with timing information
+ */
+interface TranscriptionSegment {
+    /** Unique identifier for the segment */
+    id: string;
+    /** The transcribed text for this segment */
+    text: string;
+    /** Start time in milliseconds */
+    start: number;
+    /** End time in milliseconds */
+    end: number;
+    /** Whether this segment is finalized */
+    isFinal: boolean;
+    /** Confidence score (0-1) */
+    confidence?: number;
+}
+
+/**
+ * Supported transcription providers
+ */
+declare enum TranscriptionProvider {
+    /** Browser-native Web Speech API */
+    WebSpeechAPI = "web-speech",
+    /** Deepgram real-time transcription */
+    Deepgram = "deepgram",
+    /** AssemblyAI real-time transcription */
+    AssemblyAI = "assemblyai",
+    /** Custom provider implementation */
+    Custom = "custom"
+}
+/**
+ * Audio encoding formats
+ */
+declare enum AudioEncoding {
+    /** 16-bit signed little-endian linear PCM */
+    LINEAR16 = "linear16",
+    /** G.711 mu-law */
+    MULAW = "mulaw",
+    /** G.711 A-law */
+    ALAW = "alaw",
+    /** Opus encoding */
+    OPUS = "opus"
+}
+/**
+ * Audio configuration options
+ */
+interface AudioConfig {
+    /** Sample rate in Hz (default: 16000) */
+    sampleRate?: number;
+    /** Number of audio channels (default: 1) */
+    channels?: number;
+    /** Bit depth (default: 16) */
+    bitDepth?: number;
+    /** Audio encoding format */
+    encoding?: AudioEncoding;
+}
+/**
+ * Main configuration for transcription
+ */
+interface TranscriptionConfig {
+    /** The transcription provider to use */
+    provider: TranscriptionProvider;
+    /** API key for cloud providers (Deepgram, AssemblyAI) */
+    apiKey?: string;
+    /** Language code (default: 'en-US') */
+    language?: string;
+    /** Whether to return interim results (default: true) */
+    interimResults?: boolean;
+    /** Enable profanity filter (default: false) */
+    profanityFilter?: boolean;
+    /** Enable automatic punctuation (default: true) */
+    punctuation?: boolean;
+    /** Audio configuration options */
+    audioConfig?: AudioConfig;
+    /** Provider-specific options */
+    providerOptions?: Record<string, unknown>;
+}
+/**
+ * Default audio configuration values
+ */
+declare const DEFAULT_AUDIO_CONFIG: Required<AudioConfig>;
+/**
+ * Default transcription configuration values
+ */
+declare const DEFAULT_TRANSCRIPTION_CONFIG: Partial<TranscriptionConfig>;
+
+/**
+ * Possible states of a transcription session
+ */
+declare enum SessionState {
+    /** Session has not started */
+    IDLE = "idle",
+    /** Session is initializing (connecting to provider, requesting mic access) */
+    INITIALIZING = "initializing",
+    /** Session is actively transcribing */
+    ACTIVE = "active",
+    /** Session is paused */
+    PAUSED = "paused",
+    /** Session is stopping */
+    STOPPING = "stopping",
+    /** Session has stopped */
+    STOPPED = "stopped",
+    /** Session encountered an error */
+    ERROR = "error"
+}
+/**
+ * Configuration options for a transcription session
+ */
+interface SessionConfig {
+    /** Whether to record audio during the session (default: false) */
+    recordAudio?: boolean;
+    /** Maximum session duration in milliseconds */
+    maxDuration?: number;
+    /** Auto-stop after silence duration in milliseconds */
+    silenceTimeout?: number;
+    /** Enable Voice Activity Detection (default: false) */
+    enableVAD?: boolean;
+    /** VAD sensitivity threshold (0-1, default: 0.5) */
+    vadThreshold?: number;
+}
+/**
+ * Metadata about a transcription session
+ */
+interface SessionMetadata {
+    /** Unique session identifier */
+    id: string;
+    /** Session start time (Unix timestamp) */
+    startTime: number;
+    /** Session end time (Unix timestamp) */
+    endTime?: number;
+    /** Session duration in milliseconds */
+    duration?: number;
+    /** Total word count in the session */
+    wordCount: number;
+    /** Provider used for the session */
+    provider: TranscriptionProvider;
+}
+/**
+ * Default session configuration values
+ */
+declare const DEFAULT_SESSION_CONFIG: Required<SessionConfig>;
+/**
+ * Statistics for all managed sessions
+ */
+interface SessionStats {
+    /** Total number of sessions */
+    totalSessions: number;
+    /** Number of currently active sessions */
+    activeSessions: number;
+    /** Total number of transcripts across all sessions */
+    totalTranscripts: number;
+    /** Total duration across all sessions in ms */
+    totalDuration: number;
+    /** Average confidence score */
+    averageConfidence: number;
+}
+/**
+ * Statistics for a single session
+ */
+interface SessionStatistics {
+    /** Total word count */
+    wordCount: number;
+    /** Average confidence score */
+    averageConfidence: number;
+    /** Speaking rate in words per minute */
+    speakingRate: number;
+    /** Number of silence periods */
+    silencePeriods: number;
+    /** Total duration in milliseconds */
+    durationMs: number;
+    /** Number of transcripts */
+    transcriptCount: number;
+}
+/**
+ * Options for merging transcripts
+ */
+interface MergeOptions {
+    /** Separator between transcripts */
+    separator?: string;
+    /** Include timestamps */
+    includeTimestamps?: boolean;
+    /** Include speaker labels */
+    includeSpeakers?: boolean;
+    /** Only include final transcripts */
+    finalOnly?: boolean;
+}
+/**
+ * Supported export formats
+ */
+type ExportFormat = 'json' | 'text' | 'srt' | 'vtt' | 'csv';
+/**
+ * Result of exporting a session
+ */
+interface ExportResult {
+    /** Export format used */
+    format: ExportFormat;
+    /** Exported data */
+    data: string | ArrayBuffer;
+    /** Suggested filename */
+    filename: string;
+    /** MIME type */
+    mimeType: string;
+}
+/**
+ * Data structure for importing a session
+ */
+interface SessionImport {
+    /** Session metadata */
+    metadata: SessionMetadata;
+    /** Transcript results */
+    transcripts: TranscriptionResult[];
+    /** Session configuration */
+    config: SessionConfig;
+}
+/**
+ * Full session export data
+ */
+interface SessionExportData {
+    /** Export version */
+    version: string;
+    /** Session data */
+    session: SessionImport;
+    /** Export timestamp */
+    exportedAt: number;
+}
+/**
+ * Options for text export
+ */
+interface TextExportOptions {
+    /** Include timestamps */
+    includeTimestamps?: boolean;
+    /** Include speaker labels */
+    includeSpeakers?: boolean;
+    /** Include confidence scores */
+    includeConfidence?: boolean;
+    /** Add paragraph breaks */
+    paragraphBreaks?: boolean;
+}
+/**
+ * Options for CSV export
+ */
+interface CSVExportOptions {
+    /** Column delimiter */
+    delimiter?: string;
+    /** Include header row */
+    includeHeaders?: boolean;
+    /** Columns to include */
+    columns?: string[];
+}
+
+/**
+ * Error codes for transcription errors
+ */
+declare enum ErrorCode {
+    /** Failed to initialize the provider */
+    INITIALIZATION_FAILED = "initialization_failed",
+    /** Failed to connect to the transcription service */
+    CONNECTION_FAILED = "connection_failed",
+    /** API key invalid or authentication failed */
+    AUTHENTICATION_FAILED = "authentication_failed",
+    /** Microphone access was denied by the user */
+    MICROPHONE_ACCESS_DENIED = "microphone_access_denied",
+    /** Browser does not support required features */
+    UNSUPPORTED_BROWSER = "unsupported_browser",
+    /** Network error during transcription */
+    NETWORK_ERROR = "network_error",
+    /** Provider-specific error */
+    PROVIDER_ERROR = "provider_error",
+    /** Invalid configuration provided */
+    INVALID_CONFIG = "invalid_config",
+    /** Session has expired */
+    SESSION_EXPIRED = "session_expired",
+    /** Unknown error occurred */
+    UNKNOWN_ERROR = "unknown_error"
+}
+/**
+ * Custom error class for transcription errors
+ */
+declare class TranscriptionError extends Error {
+    /** Error code identifying the type of error */
+    readonly code: ErrorCode;
+    /** Provider that generated the error */
+    readonly provider?: TranscriptionProvider;
+    /** Additional error details */
+    readonly details?: unknown;
+    constructor(message: string, code: ErrorCode, provider?: TranscriptionProvider, details?: unknown);
+}
+/**
+ * Event map for transcription events
+ * Used for type-safe event handling
+ */
+interface TranscriptionEvents {
+    /** Emitted for any transcription result (interim or final) */
+    transcript: (result: TranscriptionResult) => void;
+    /** Emitted for interim (non-final) transcription results */
+    interim: (result: TranscriptionResult) => void;
+    /** Emitted for final transcription results */
+    final: (result: TranscriptionResult) => void;
+    /** Emitted when transcription starts */
+    start: () => void;
+    /** Emitted when transcription stops */
+    stop: () => void;
+    /** Emitted when transcription is paused */
+    pause: () => void;
+    /** Emitted when transcription is resumed */
+    resume: () => void;
+    /** Emitted when an error occurs */
+    error: (error: TranscriptionError) => void;
+    /** Emitted when session state changes */
+    stateChange: (state: SessionState) => void;
+    /** Emitted with current audio level (0-1) */
+    audioLevel: (level: number) => void;
+    /** Emitted when silence is detected */
+    silence: () => void;
+    /** Emitted when speech is detected */
+    speech: () => void;
+    /** Index signature for extensibility */
+    [key: string]: (...args: any[]) => void;
+}
+/**
+ * Type for event names
+ */
+type TranscriptionEventName = keyof TranscriptionEvents;
+
+/**
+ * Interface that all transcription providers must implement
+ */
+interface ITranscriptionProvider {
+    /**
+     * Initialize the provider with configuration
+     * @param config - Transcription configuration
+     */
+    initialize(config: TranscriptionConfig): Promise<void>;
+    /**
+     * Start transcription
+     */
+    start(): Promise<void>;
+    /**
+     * Stop transcription
+     */
+    stop(): Promise<void>;
+    /**
+     * Pause transcription
+     */
+    pause(): void;
+    /**
+     * Resume transcription after pause
+     */
+    resume(): void;
+    /**
+     * Send audio data to the provider
+     * @param audioData - Raw audio data as ArrayBuffer
+     */
+    sendAudio(audioData: ArrayBuffer): void;
+    /**
+     * Get the current session state
+     */
+    getState(): SessionState;
+    /**
+     * Check if this provider is supported in the current environment
+     */
+    isSupported(): boolean;
+    /**
+     * Clean up resources and connections
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Describes the capabilities of a transcription provider
+ */
+interface ProviderCapabilities {
+    /** Whether the provider supports interim (partial) results */
+    supportsInterim: boolean;
+    /** Whether the provider provides word-level timestamps */
+    supportsWordTimestamps: boolean;
+    /** Whether the provider supports speaker diarization */
+    supportsSpeakerDiarization: boolean;
+    /** Whether the provider supports automatic punctuation */
+    supportsPunctuation: boolean;
+    /** Whether the provider supports automatic language detection */
+    supportsLanguageDetection: boolean;
+    /** List of supported language codes */
+    supportedLanguages: string[];
+}
+/**
+ * Base provider information
+ */
+interface ProviderInfo {
+    /** Provider display name */
+    name: string;
+    /** Provider identifier */
+    id: string;
+    /** Provider capabilities */
+    capabilities: ProviderCapabilities;
+    /** Whether the provider requires an API key */
+    requiresApiKey: boolean;
+    /** Whether the provider works in browser environment */
+    supportsBrowser: boolean;
+    /** Whether the provider works in Node.js environment */
+    supportsNode: boolean;
+}
+
+/**
+ * Abstract base class for all transcription providers
+ * Provides common functionality including event handling, session management,
+ * and audio recording capabilities
+ */
+declare abstract class BaseTranscriber extends EventEmitter<TranscriptionEvents> implements ITranscriptionProvider {
+    /** Transcription configuration */
+    protected config: TranscriptionConfig;
+    /** Current session state */
+    protected state: SessionState;
+    /** Session metadata */
+    protected sessionMetadata: SessionMetadata;
+    /** Recorded audio chunks */
+    protected audioRecording: ArrayBuffer[];
+    /** Session start timestamp */
+    protected startTime?: number;
+    /** Word count in current session */
+    protected wordCount: number;
+    /**
+     * Create a new BaseTranscriber instance
+     * @param config - Transcription configuration
+     */
+    constructor(config: TranscriptionConfig);
+    /**
+     * Initialize the provider with configuration
+     * Must be implemented by concrete providers
+     */
+    abstract initialize(): Promise<void>;
+    /**
+     * Start transcription
+     * Must be implemented by concrete providers
+     */
+    abstract start(): Promise<void>;
+    /**
+     * Stop transcription
+     * Must be implemented by concrete providers
+     */
+    abstract stop(): Promise<void>;
+    /**
+     * Pause transcription
+     * Must be implemented by concrete providers
+     */
+    abstract pause(): void;
+    /**
+     * Resume transcription after pause
+     * Must be implemented by concrete providers
+     */
+    abstract resume(): void;
+    /**
+     * Send audio data to the provider
+     * Must be implemented by concrete providers
+     * @param audioData - Raw audio data
+     */
+    abstract sendAudio(audioData: ArrayBuffer): void;
+    /**
+     * Check if provider is supported in current environment
+     * Must be implemented by concrete providers
+     */
+    abstract isSupported(): boolean;
+    /**
+     * Clean up resources and connections
+     * Must be implemented by concrete providers
+     */
+    abstract cleanup(): Promise<void>;
+    /**
+     * Get the current session state
+     */
+    getState(): SessionState;
+    /**
+     * Get session metadata
+     */
+    getMetadata(): SessionMetadata;
+    /**
+     * Get recorded audio data
+     * @returns Combined audio data or null if not recording
+     */
+    getRecording(): ArrayBuffer | null;
+    /**
+     * Update session state and emit state change event
+     * @param newState - New session state
+     */
+    protected setState(newState: SessionState): void;
+    /**
+     * Handle incoming transcription result
+     * @param result - Transcription result from provider
+     */
+    protected handleTranscript(result: TranscriptionResult): void;
+    /**
+     * Handle errors and emit error event
+     * @param error - Error to handle
+     */
+    protected handleError(error: Error | TranscriptionError): void;
+    /**
+     * Validate configuration
+     * @throws TranscriptionError if configuration is invalid
+     */
+    protected validateConfig(): void;
+    /**
+     * Record audio data if recording is enabled
+     * @param data - Audio data to record
+     */
+    protected recordAudioData(data: ArrayBuffer): void;
+    /**
+     * Calculate session duration
+     * @returns Duration in milliseconds
+     */
+    protected calculateDuration(): number;
+    /**
+     * Clear recording data
+     */
+    protected clearRecording(): void;
+    /**
+     * Reset session state for new session
+     */
+    protected resetSession(): void;
+    /**
+     * Generate a unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Initialize session metadata
+     */
+    private initializeMetadata;
+}
+
+/**
+ * Session export data structure
+ */
+interface SessionExport {
+    /** Session metadata */
+    metadata: SessionMetadata;
+    /** All transcription results */
+    transcripts: TranscriptionResult[];
+    /** Concatenated final text */
+    fullText: string;
+    /** Recorded audio data if available */
+    audioData?: ArrayBuffer;
+}
+/**
+ * Manages a transcription session with support for recording and transcript management
+ */
+declare class TranscriptionSession {
+    /** Unique session identifier */
+    readonly id: string;
+    /** Transcription provider instance */
+    readonly provider: ITranscriptionProvider;
+    /** Session configuration */
+    private config;
+    /** Collected transcription results */
+    private transcripts;
+    /** Current session state */
+    private state;
+    /** Max duration timer */
+    private maxDurationTimer?;
+    /** Silence timeout timer */
+    private silenceTimer?;
+    /** Session start timestamp */
+    private startTime?;
+    /**
+     * Create a new TranscriptionSession
+     * @param provider - Transcription provider to use
+     * @param sessionConfig - Session configuration options
+     */
+    constructor(provider: ITranscriptionProvider, sessionConfig?: SessionConfig);
+    /**
+     * Start the transcription session
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the transcription session
+     */
+    stop(): Promise<void>;
+    /**
+     * Pause the transcription session
+     */
+    pause(): void;
+    /**
+     * Resume the transcription session
+     */
+    resume(): void;
+    /**
+     * Add a transcription result to the session
+     * @param result - Transcription result to add
+     */
+    addTranscript(result: TranscriptionResult): void;
+    /**
+     * Get transcription results
+     * @param finalOnly - If true, return only final results
+     */
+    getTranscripts(finalOnly?: boolean): TranscriptionResult[];
+    /**
+     * Get concatenated text from all final transcripts
+     */
+    getFullText(): string;
+    /**
+     * Get the current session state
+     */
+    getState(): SessionState;
+    /**
+     * Export session data in raw format
+     */
+    exportRaw(): SessionExport;
+    /**
+     * Export session data in specified format
+     * @param format - Export format (json, text, srt, vtt, csv)
+     */
+    export(format?: ExportFormat): ExportResult;
+    /**
+     * Get session statistics
+     */
+    getStatistics(): SessionStatistics;
+    /**
+     * Clear all transcripts
+     */
+    clear(): void;
+    /**
+     * Get the total word count from final transcripts
+     */
+    private getWordCount;
+    /**
+     * Set up session timers (max duration, silence timeout)
+     */
+    private setupTimers;
+    /**
+     * Reset the silence timeout timer
+     */
+    private resetSilenceTimer;
+    /**
+     * Clear all timers
+     */
+    private clearTimers;
+    /**
+     * Generate a unique session ID
+     */
+    private generateSessionId;
+}
+
+/**
+ * Session manager options
+ */
+interface SessionManagerOptions {
+    /** Default session configuration */
+    defaultConfig?: SessionConfig;
+    /** Maximum number of concurrent sessions */
+    maxSessions?: number;
+}
+/**
+ * Manages multiple transcription sessions
+ */
+declare class SessionManager {
+    /** Active sessions map */
+    private sessions;
+    /** Currently active session ID */
+    private activeSessionId;
+    /** Default session configuration */
+    private defaultConfig;
+    /** Maximum number of sessions */
+    private maxSessions;
+    /**
+     * Create a new SessionManager
+     * @param options - Manager configuration
+     */
+    constructor(options?: SessionManagerOptions);
+    /**
+     * Create a new transcription session
+     * @param provider - Transcription provider instance
+     * @param config - Session configuration (merged with defaults)
+     * @returns New TranscriptionSession instance
+     */
+    createSession(provider: ITranscriptionProvider, config?: SessionConfig): TranscriptionSession;
+    /**
+     * Get session by ID
+     * @param sessionId - Session ID
+     * @returns TranscriptionSession or null
+     */
+    getSession(sessionId: string): TranscriptionSession | null;
+    /**
+     * Get the currently active session
+     * @returns Active TranscriptionSession or null
+     */
+    getActiveSession(): TranscriptionSession | null;
+    /**
+     * Set the active session
+     * @param sessionId - Session ID to make active
+     */
+    setActiveSession(sessionId: string): void;
+    /**
+     * Get all sessions
+     * @returns Array of all sessions
+     */
+    getAllSessions(): TranscriptionSession[];
+    /**
+     * Delete a session
+     * @param sessionId - Session ID to delete
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Clear all sessions
+     */
+    clearAllSessions(): Promise<void>;
+    /**
+     * Get statistics for all sessions
+     * @returns Session statistics
+     */
+    getSessionStats(): SessionStats;
+    /**
+     * Export a session to specified format
+     * @param sessionId - Session ID
+     * @param format - Export format
+     * @returns Export result
+     */
+    exportSession(sessionId: string, format: ExportFormat): ExportResult;
+    /**
+     * Import a session from data
+     * @param data - Session import data
+     * @param provider - Provider instance for the session
+     * @returns Imported session
+     */
+    importSession(data: SessionImport, provider: ITranscriptionProvider): TranscriptionSession;
+    /**
+     * Check if a session exists
+     * @param sessionId - Session ID
+     * @returns True if session exists
+     */
+    hasSession(sessionId: string): boolean;
+    /**
+     * Get session count
+     * @returns Number of sessions
+     */
+    getSessionCount(): number;
+    /**
+     * Get sessions by state
+     * @param state - Session state to filter by
+     * @returns Array of sessions with matching state
+     */
+    getSessionsByState(state: SessionState): TranscriptionSession[];
+}
+
+/**
+ * Web Speech API type declarations
+ */
+declare global {
+    interface Window {
+        SpeechRecognition: typeof SpeechRecognition;
+        webkitSpeechRecognition: typeof SpeechRecognition;
+    }
+}
+/**
+ * SpeechRecognition interfaces for TypeScript
+ */
+interface SpeechRecognitionEvent extends Event {
+    resultIndex: number;
+    results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionResultList {
+    length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResult;
+}
+interface SpeechRecognitionResult {
+    length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+    isFinal: boolean;
+}
+interface SpeechRecognitionAlternative {
+    transcript: string;
+    confidence: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    error: string;
+    message: string;
+}
+interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    maxAlternatives: number;
+    grammars: unknown;
+    onstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onend: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => void) | null;
+    onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => void) | null;
+    onspeechstart: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onspeechend: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onaudiostart: ((this: SpeechRecognition, ev: Event) => void) | null;
+    onaudioend: ((this: SpeechRecognition, ev: Event) => void) | null;
+    start(): void;
+    stop(): void;
+    abort(): void;
+}
+declare let SpeechRecognition: {
+    prototype: SpeechRecognition;
+    new (): SpeechRecognition;
+};
+/**
+ * Transcription provider using browser's native Web Speech API
+ * Works in Chrome, Edge, and Safari without requiring API keys
+ */
+declare class WebSpeechProvider extends BaseTranscriber {
+    /** Speech recognition instance */
+    private recognition;
+    /** Media stream from microphone */
+    private mediaStream;
+    /** Audio context for analysis */
+    private audioContext;
+    /** Audio analyser for VAD */
+    private analyser;
+    /** Script processor for audio level monitoring */
+    private audioLevelInterval;
+    /** Whether recognition is being restarted automatically */
+    private isRestarting;
+    /** Retry count for auto-restart */
+    private retryCount;
+    /** Maximum retry attempts */
+    private readonly maxRetries;
+    /** Provider capabilities */
+    static readonly capabilities: ProviderCapabilities;
+    /**
+     * Create a new WebSpeechProvider
+     * @param config - Transcription configuration
+     */
+    constructor(config: Omit<TranscriptionConfig, 'provider'> & {
+        provider?: TranscriptionProvider;
+    });
+    /**
+     * Check if Web Speech API is supported in the current environment
+     */
+    isSupported(): boolean;
+    /**
+     * Initialize the Web Speech API provider
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start transcription
+     */
+    start(): Promise<void>;
+    /**
+     * Stop transcription
+     */
+    stop(): Promise<void>;
+    /**
+     * Pause transcription
+     */
+    pause(): void;
+    /**
+     * Resume transcription
+     */
+    resume(): void;
+    /**
+     * Send audio data - not supported by Web Speech API
+     * @param _audioData - Audio data (unused)
+     */
+    sendAudio(_audioData: ArrayBuffer): void;
+    /**
+     * Clean up all resources
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get provider capabilities
+     */
+    getCapabilities(): ProviderCapabilities;
+    /**
+     * Set up event handlers for speech recognition
+     */
+    private setupEventHandlers;
+    /**
+     * Process speech recognition results
+     */
+    private processRecognitionResult;
+    /**
+     * Handle recognition end event
+     */
+    private handleRecognitionEnd;
+    /**
+     * Handle recognition errors
+     */
+    private handleRecognitionError;
+    /**
+     * Request microphone access
+     */
+    private getMicrophoneAccess;
+    /**
+     * Stop media stream tracks
+     */
+    private stopMediaStream;
+    /**
+     * Set up audio level monitoring for VAD
+     */
+    private setupAudioLevelMonitoring;
+    /**
+     * Stop audio level monitoring
+     */
+    private stopAudioLevelMonitoring;
+}
+
+/**
+ * Deepgram-specific configuration options
+ */
+interface DeepgramOptions {
+    /** Deepgram model to use */
+    model?: 'nova-2' | 'nova' | 'enhanced' | 'base';
+    /** Model tier */
+    tier?: 'nova' | 'enhanced' | 'base';
+    /** Model version */
+    version?: 'latest' | string;
+    /** Enable punctuation */
+    punctuate?: boolean;
+    /** Enable speaker diarization */
+    diarize?: boolean;
+    /** Enable multichannel processing */
+    multichannel?: boolean;
+    /** Number of alternative transcripts */
+    alternatives?: number;
+    /** Convert numbers to numerals */
+    numerals?: boolean;
+    /** Search terms to boost */
+    search?: string[];
+    /** Words to replace */
+    replace?: string[];
+    /** Keywords to boost */
+    keywords?: string[];
+    /** Endpointing timeout in milliseconds */
+    endpointing?: number;
+    /** Enable smart formatting */
+    smartFormat?: boolean;
+}
+/**
+ * Transcription provider using Deepgram's WebSocket streaming API
+ * Provides high-accuracy transcription with word-level timestamps
+ */
+declare class DeepgramProvider extends BaseTranscriber {
+    /** WebSocket connection */
+    private socket;
+    /** Media stream from microphone */
+    private mediaStream;
+    /** Audio context for processing */
+    private audioContext;
+    /** Audio processor node */
+    private processor;
+    /** Connection attempt counter */
+    private connectionAttempts;
+    /** Maximum reconnection attempts */
+    private readonly maxRetries;
+    /** Reconnection timeout */
+    private reconnectTimeout;
+    /** Keep-alive interval */
+    private keepAliveInterval;
+    /** Flag indicating if connection is ready */
+    private isConnectionReady;
+    /** Flag for intentional close */
+    private isIntentionalClose;
+    /** Provider capabilities */
+    static readonly capabilities: ProviderCapabilities;
+    /**
+     * Create a new DeepgramProvider
+     * @param config - Transcription configuration with API key
+     */
+    constructor(config: Omit<TranscriptionConfig, 'provider'> & {
+        provider?: TranscriptionProvider;
+    });
+    /**
+     * Check if Deepgram provider is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Initialize the Deepgram provider
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start transcription
+     */
+    start(): Promise<void>;
+    /**
+     * Stop transcription
+     */
+    stop(): Promise<void>;
+    /**
+     * Pause transcription
+     */
+    pause(): void;
+    /**
+     * Resume transcription
+     */
+    resume(): void;
+    /**
+     * Send audio data through WebSocket
+     * @param audioData - Raw audio data as ArrayBuffer
+     */
+    sendAudio(audioData: ArrayBuffer): void;
+    /**
+     * Clean up all resources
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get provider capabilities
+     */
+    getCapabilities(): ProviderCapabilities;
+    /**
+     * Build WebSocket URL with query parameters
+     */
+    private buildWebSocketUrl;
+    /**
+     * Set up WebSocket connection
+     */
+    private setupWebSocket;
+    /**
+     * Handle WebSocket open event
+     */
+    private handleWebSocketOpen;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleWebSocketMessage;
+    /**
+     * Process transcription result from Deepgram
+     */
+    private processTranscriptionResult;
+    /**
+     * Handle Deepgram-specific errors
+     */
+    private handleDeepgramError;
+    /**
+     * Handle WebSocket error
+     */
+    private handleWebSocketError;
+    /**
+     * Handle WebSocket close
+     */
+    private handleWebSocketClose;
+    /**
+     * Attempt to reconnect
+     */
+    private reconnect;
+    /**
+     * Start keep-alive interval
+     */
+    private startKeepAlive;
+    /**
+     * Stop keep-alive interval
+     */
+    private stopKeepAlive;
+    /**
+     * Request microphone access
+     */
+    private getMicrophoneAccess;
+    /**
+     * Set up audio processing pipeline
+     */
+    private setupAudioProcessing;
+    /**
+     * Stop audio processing
+     */
+    private stopAudioProcessing;
+    /**
+     * Convert Float32 audio samples to Int16
+     */
+    private convertFloat32ToInt16;
+    /**
+     * Close WebSocket connection
+     */
+    private closeWebSocket;
+    /**
+     * Stop media stream tracks
+     */
+    private stopMediaStream;
+}
+
+/**
+ * AssemblyAI-specific configuration options
+ */
+interface AssemblyAIOptions {
+    /** Keywords to boost recognition */
+    wordBoost?: string[];
+    /** Boost parameter strength */
+    boostParam?: 'low' | 'default' | 'high';
+    /** Disable partial (interim) transcripts */
+    disablePartialTranscripts?: boolean;
+    /** Auto-format text */
+    formatText?: boolean;
+    /** Enable punctuation */
+    punctuate?: boolean;
+    /** Include disfluencies (um, uh) */
+    disfluencies?: boolean;
+    /** Enable multichannel processing */
+    multichannel?: boolean;
+    /** Enable dual channel processing */
+    dualChannel?: boolean;
+    /** Enable speaker labels */
+    speakerLabels?: boolean;
+    /** Expected number of speakers */
+    speakersExpected?: number;
+    /** Enable entity detection */
+    entityDetection?: boolean;
+    /** Enable sentiment analysis */
+    sentimentAnalysis?: boolean;
+    /** Enable auto highlights */
+    autoHighlights?: boolean;
+    /** Enable content safety detection */
+    contentSafety?: boolean;
+}
+/**
+ * Transcription provider using AssemblyAI's real-time WebSocket API
+ * Provides high-accuracy transcription with advanced features
+ */
+declare class AssemblyAIProvider extends BaseTranscriber {
+    /** WebSocket connection */
+    private socket;
+    /** Media stream from microphone */
+    private mediaStream;
+    /** Audio context for processing */
+    private audioContext;
+    /** Audio processor node */
+    private processor;
+    /** Session token for WebSocket authentication */
+    private sessionToken;
+    /** Connection attempt counter */
+    private connectionAttempts;
+    /** Maximum reconnection attempts */
+    private readonly maxRetries;
+    /** Reconnection timeout */
+    private reconnectTimeout;
+    /** Flag indicating if connection is ready */
+    private isConnectionReady;
+    /** Flag for intentional close */
+    private isIntentionalClose;
+    /** Session ID from AssemblyAI */
+    private sessionId;
+    /** Provider capabilities */
+    static readonly capabilities: ProviderCapabilities;
+    /**
+     * Create a new AssemblyAIProvider
+     * @param config - Transcription configuration with API key
+     */
+    constructor(config: Omit<TranscriptionConfig, 'provider'> & {
+        provider?: TranscriptionProvider;
+    });
+    /**
+     * Check if AssemblyAI provider is supported
+     */
+    isSupported(): boolean;
+    /**
+     * Initialize the AssemblyAI provider
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start transcription
+     */
+    start(): Promise<void>;
+    /**
+     * Stop transcription
+     */
+    stop(): Promise<void>;
+    /**
+     * Pause transcription
+     */
+    pause(): void;
+    /**
+     * Resume transcription
+     */
+    resume(): void;
+    /**
+     * Send audio data through WebSocket
+     * @param audioData - Raw audio data as ArrayBuffer
+     */
+    sendAudio(audioData: ArrayBuffer): void;
+    /**
+     * Clean up all resources
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get provider capabilities
+     */
+    getCapabilities(): ProviderCapabilities;
+    /**
+     * Get temporary session token from AssemblyAI
+     */
+    private getSessionToken;
+    /**
+     * Set up WebSocket connection
+     */
+    private setupWebSocket;
+    /**
+     * Handle WebSocket open event
+     */
+    private handleWebSocketOpen;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleWebSocketMessage;
+    /**
+     * Handle SessionBegins message
+     */
+    private handleSessionBegins;
+    /**
+     * Handle partial (interim) transcript
+     */
+    private handlePartialTranscript;
+    /**
+     * Handle final transcript
+     */
+    private handleFinalTranscript;
+    /**
+     * Handle session terminated message
+     */
+    private handleSessionTerminated;
+    /**
+     * Handle AssemblyAI-specific errors
+     */
+    private handleAssemblyAIError;
+    /**
+     * Handle WebSocket error
+     */
+    private handleWebSocketError;
+    /**
+     * Handle WebSocket close
+     */
+    private handleWebSocketClose;
+    /**
+     * Attempt to reconnect
+     */
+    private reconnect;
+    /**
+     * Request microphone access
+     */
+    private getMicrophoneAccess;
+    /**
+     * Set up audio processing pipeline
+     */
+    private setupAudioProcessing;
+    /**
+     * Stop audio processing
+     */
+    private stopAudioProcessing;
+    /**
+     * Convert Float32 audio samples to PCM16 (Int16)
+     */
+    private convertFloat32ToPCM16;
+    /**
+     * Encode ArrayBuffer to base64
+     */
+    private encodeAudioToBase64;
+    /**
+     * Send audio data message
+     */
+    private sendAudioMessage;
+    /**
+     * Send terminate session message
+     */
+    private sendTerminateMessage;
+    /**
+     * Close WebSocket connection
+     */
+    private closeWebSocket;
+    /**
+     * Stop media stream tracks
+     */
+    private stopMediaStream;
+}
+
+/**
+ * Static utility class for audio processing operations
+ * Provides conversion, resampling, and format utilities
+ */
+declare class AudioProcessor {
+    /**
+     * Convert Float32 audio samples to Int16
+     * @param buffer - Input Float32Array
+     * @returns Int16Array of converted samples
+     */
+    static convertFloat32ToInt16(buffer: Float32Array): Int16Array;
+    /**
+     * Convert Int16 audio samples to Float32
+     * @param buffer - Input Int16Array
+     * @returns Float32Array of converted samples
+     */
+    static convertInt16ToFloat32(buffer: Int16Array): Float32Array;
+    /**
+     * Resample audio buffer to different sample rate
+     * Uses linear interpolation
+     * @param buffer - Input audio buffer
+     * @param fromRate - Source sample rate
+     * @param toRate - Target sample rate
+     * @returns Resampled Float32Array
+     */
+    static resampleBuffer(buffer: Float32Array, fromRate: number, toRate: number): Float32Array;
+    /**
+     * Downsample audio buffer (optimized for reducing sample rate)
+     * @param buffer - Input audio buffer
+     * @param fromRate - Source sample rate
+     * @param toRate - Target sample rate
+     * @returns Downsampled Float32Array
+     */
+    static downsampleBuffer(buffer: Float32Array, fromRate: number, toRate: number): Float32Array;
+    /**
+     * Upsample audio buffer (optimized for increasing sample rate)
+     * @param buffer - Input audio buffer
+     * @param fromRate - Source sample rate
+     * @param toRate - Target sample rate
+     * @returns Upsampled Float32Array
+     */
+    static upsampleBuffer(buffer: Float32Array, fromRate: number, toRate: number): Float32Array;
+    /**
+     * Normalize audio buffer to peak amplitude of 1.0
+     * @param buffer - Input audio buffer
+     * @returns Normalized Float32Array
+     */
+    static normalizeBuffer(buffer: Float32Array): Float32Array;
+    /**
+     * Apply gain to audio buffer
+     * @param buffer - Input audio buffer
+     * @param gain - Gain multiplier
+     * @returns Processed Float32Array
+     */
+    static applyGain(buffer: Float32Array, gain: number): Float32Array;
+    /**
+     * Mix two audio buffers together
+     * @param buffer1 - First audio buffer
+     * @param buffer2 - Second audio buffer
+     * @param ratio - Mix ratio (0-1, where 0.5 is equal mix)
+     * @returns Mixed Float32Array
+     */
+    static mixBuffers(buffer1: Float32Array, buffer2: Float32Array, ratio?: number): Float32Array;
+    /**
+     * Convert AudioBuffer to WAV format
+     * @param audioBuffer - Web Audio API AudioBuffer
+     * @param sampleRate - Output sample rate (defaults to buffer's sample rate)
+     * @returns WAV file as ArrayBuffer
+     */
+    static bufferToWav(audioBuffer: AudioBuffer, sampleRate?: number): ArrayBuffer;
+    /**
+     * Create WAV file header
+     * @param dataLength - Length of audio data in bytes
+     * @param sampleRate - Sample rate
+     * @param channels - Number of channels
+     * @param bitDepth - Bits per sample
+     * @returns WAV header as ArrayBuffer
+     */
+    static createWavHeader(dataLength: number, sampleRate: number, channels: number, bitDepth: number): ArrayBuffer;
+    /**
+     * Write string to DataView
+     * @param view - DataView to write to
+     * @param offset - Byte offset
+     * @param string - String to write
+     */
+    private static writeString;
+    /**
+     * Convert raw PCM Float32 array to WAV ArrayBuffer
+     * @param samples - Float32Array of audio samples
+     * @param sampleRate - Sample rate
+     * @returns WAV file as ArrayBuffer
+     */
+    static float32ToWav(samples: Float32Array, sampleRate: number): ArrayBuffer;
+}
+
+/**
+ * Voice Activity Detection options
+ */
+interface VADOptions {
+    /** Energy threshold for speech detection (0-1, default: 0.01) */
+    threshold?: number;
+    /** Minimum duration of speech in ms to trigger start (default: 300) */
+    minSpeechDuration?: number;
+    /** Minimum duration of silence in ms to trigger end (default: 500) */
+    minSilenceDuration?: number;
+    /** Size of energy history buffer (default: 10) */
+    historySize?: number;
+    /** Callback when speech starts */
+    onSpeechStart?: () => void;
+    /** Callback when speech ends */
+    onSpeechEnd?: () => void;
+    /** Callback for volume level changes */
+    onVolumeChange?: (level: number) => void;
+}
+/**
+ * Voice Activity Detector using energy-based detection
+ * Detects speech and silence in audio streams
+ */
+declare class VoiceActivityDetector {
+    /** Energy threshold for speech detection */
+    private threshold;
+    /** Minimum speech duration in ms */
+    private minSpeechDuration;
+    /** Minimum silence duration in ms */
+    private minSilenceDuration;
+    /** Energy history buffer */
+    private energyHistory;
+    /** History buffer size */
+    private historySize;
+    /** Current speaking state */
+    private isSpeaking;
+    /** Speech start time */
+    private speechStartTime;
+    /** Silence start time */
+    private silenceStartTime;
+    /** Speech start callback */
+    private onSpeechStart?;
+    /** Speech end callback */
+    private onSpeechEnd?;
+    /** Volume change callback */
+    private onVolumeChange?;
+    /** Last processed timestamp */
+    private lastProcessTime;
+    /**
+     * Create a new VoiceActivityDetector
+     * @param options - VAD configuration options
+     */
+    constructor(options?: VADOptions);
+    /**
+     * Process audio data and detect voice activity
+     * @param audioData - Audio samples as Float32Array
+     * @returns Current speaking state
+     */
+    processAudio(audioData: Float32Array): boolean;
+    /**
+     * Calculate RMS (Root Mean Square) energy of audio buffer
+     * @param buffer - Audio samples
+     * @returns RMS energy value (0-1)
+     */
+    calculateRMSEnergy(buffer: Float32Array): number;
+    /**
+     * Calculate adaptive threshold based on energy history
+     * @returns Adaptive threshold value
+     */
+    calculateAdaptiveThreshold(): number;
+    /**
+     * Reset detector state
+     */
+    reset(): void;
+    /**
+     * Update threshold value
+     * @param threshold - New threshold (0-1)
+     */
+    setThreshold(threshold: number): void;
+    /**
+     * Get average energy from history
+     * @returns Average energy value
+     */
+    getAverageEnergy(): number;
+    /**
+     * Check if speech is currently detected
+     * @returns Speaking state
+     */
+    isSpeechDetected(): boolean;
+    /**
+     * Get current threshold
+     * @returns Threshold value
+     */
+    getThreshold(): number;
+    /**
+     * Update callbacks
+     * @param callbacks - New callback functions
+     */
+    setCallbacks(callbacks: {
+        onSpeechStart?: () => void;
+        onSpeechEnd?: () => void;
+        onVolumeChange?: (level: number) => void;
+    }): void;
+}
+
+/**
+ * Audio level monitor options
+ */
+interface AudioLevelMonitorOptions {
+    /** Smoothing factor for level calculation (0-1, default: 0.8) */
+    smoothingFactor?: number;
+    /** Callback for level changes */
+    onLevelChange?: (level: number) => void;
+}
+/**
+ * Monitors and reports audio levels with smoothing
+ */
+declare class AudioLevelMonitor {
+    /** Smoothing factor (0-1, higher = smoother) */
+    private smoothingFactor;
+    /** Current smoothed level */
+    private currentLevel;
+    /** Peak level since last reset */
+    private peakLevel;
+    /** Level change callback */
+    private onLevelChange?;
+    /**
+     * Create a new AudioLevelMonitor
+     * @param options - Monitor configuration
+     */
+    constructor(options?: AudioLevelMonitorOptions);
+    /**
+     * Process audio data and update levels
+     * @param audioData - Audio samples as Float32Array
+     * @returns Current smoothed level
+     */
+    processAudio(audioData: Float32Array): number;
+    /**
+     * Calculate RMS level of audio buffer
+     * @param buffer - Audio samples
+     * @returns Level value (0-1)
+     */
+    calculateLevel(buffer: Float32Array): number;
+    /**
+     * Get current smoothed level
+     * @returns Current level (0-1)
+     */
+    getCurrentLevel(): number;
+    /**
+     * Get peak level since last reset
+     * @returns Peak level (0-1)
+     */
+    getPeakLevel(): number;
+    /**
+     * Reset current and peak levels
+     */
+    reset(): void;
+    /**
+     * Reset only the peak level
+     */
+    resetPeak(): void;
+    /**
+     * Convert current level to decibels
+     * @returns Level in dB (typically -60 to 0)
+     */
+    getDecibels(): number;
+    /**
+     * Convert specific level to decibels
+     * @param level - Level value (0-1)
+     * @returns Level in dB
+     */
+    static toDecibels(level: number): number;
+    /**
+     * Convert decibels to linear level
+     * @param db - Level in decibels
+     * @returns Linear level (0-1)
+     */
+    static fromDecibels(db: number): number;
+    /**
+     * Set smoothing factor
+     * @param factor - Smoothing factor (0-1)
+     */
+    setSmoothingFactor(factor: number): void;
+    /**
+     * Get current smoothing factor
+     * @returns Smoothing factor
+     */
+    getSmoothingFactor(): number;
+    /**
+     * Set level change callback
+     * @param callback - Callback function
+     */
+    setOnLevelChange(callback: ((level: number) => void) | undefined): void;
+    /**
+     * Get level as percentage (0-100)
+     * @returns Level percentage
+     */
+    getLevelPercentage(): number;
+}
+
+/**
+ * Circular buffer manager for audio chunks
+ * Efficiently manages audio data for streaming applications
+ */
+declare class AudioBufferManager {
+    /** Maximum number of chunks to store */
+    private bufferSize;
+    /** Buffer storage */
+    private buffer;
+    /** Write position */
+    private writeIndex;
+    /** Read position */
+    private readIndex;
+    /** Number of available chunks */
+    private count;
+    /**
+     * Create a new AudioBufferManager
+     * @param bufferSize - Maximum number of chunks to store
+     */
+    constructor(bufferSize?: number);
+    /**
+     * Write a chunk to the buffer
+     * @param chunk - Audio data chunk
+     */
+    write(chunk: Float32Array): void;
+    /**
+     * Read and remove chunks from the buffer
+     * @param numChunks - Number of chunks to read (default: all available)
+     * @returns Array of audio chunks
+     */
+    read(numChunks?: number): Float32Array[];
+    /**
+     * Read chunks without removing them
+     * @param numChunks - Number of chunks to peek (default: all available)
+     * @returns Array of audio chunks
+     */
+    peek(numChunks?: number): Float32Array[];
+    /**
+     * Clear all data from buffer
+     */
+    clear(): void;
+    /**
+     * Get number of available chunks
+     * @returns Number of chunks in buffer
+     */
+    getAvailableChunks(): number;
+    /**
+     * Check if buffer is full
+     * @returns True if buffer is full
+     */
+    isFull(): boolean;
+    /**
+     * Check if buffer is empty
+     * @returns True if buffer is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Concatenate multiple chunks into a single buffer
+     * @param chunks - Array of audio chunks
+     * @returns Single concatenated Float32Array
+     */
+    concatenateChunks(chunks: Float32Array[]): Float32Array;
+    /**
+     * Get all data as a single concatenated buffer
+     * @returns Concatenated Float32Array
+     */
+    getAll(): Float32Array;
+    /**
+     * Get total number of samples across all chunks
+     * @returns Total sample count
+     */
+    getTotalSamples(): number;
+    /**
+     * Get buffer capacity
+     * @returns Maximum number of chunks
+     */
+    getCapacity(): number;
+    /**
+     * Resize the buffer
+     * @param newSize - New buffer size
+     */
+    resize(newSize: number): void;
+}
+
+/**
+ * Audio recording format
+ */
+type AudioFormat = 'raw' | 'wav';
+/**
+ * Records audio chunks and exports to various formats
+ */
+declare class AudioRecorder {
+    /** Recorded audio chunks */
+    private audioChunks;
+    /** Sample rate */
+    private sampleRate;
+    /** Recording state */
+    private isRecording;
+    /** Recording start time */
+    private startTime;
+    /**
+     * Create a new AudioRecorder
+     * @param sampleRate - Sample rate for recording
+     */
+    constructor(sampleRate?: number);
+    /**
+     * Start recording
+     */
+    start(): void;
+    /**
+     * Record an audio chunk
+     * @param audioData - Audio data to record
+     */
+    recordChunk(audioData: Float32Array): void;
+    /**
+     * Stop recording and return all recorded audio
+     * @returns Complete audio as Float32Array
+     */
+    stop(): Float32Array;
+    /**
+     * Clear all recorded audio
+     */
+    clear(): void;
+    /**
+     * Export recording to specified format
+     * @param format - Output format ('raw' or 'wav')
+     * @returns Audio data as ArrayBuffer
+     */
+    export(format?: AudioFormat): ArrayBuffer;
+    /**
+     * Get recording duration in seconds
+     * @returns Duration in seconds
+     */
+    getDuration(): number;
+    /**
+     * Get number of recorded chunks
+     * @returns Chunk count
+     */
+    getChunkCount(): number;
+    /**
+     * Check if currently recording
+     * @returns Recording state
+     */
+    getIsRecording(): boolean;
+    /**
+     * Get sample rate
+     * @returns Sample rate
+     */
+    getSampleRate(): number;
+    /**
+     * Set sample rate (only effective before recording starts)
+     * @param sampleRate - New sample rate
+     */
+    setSampleRate(sampleRate: number): void;
+    /**
+     * Get total number of recorded samples
+     * @returns Sample count
+     */
+    getTotalSamples(): number;
+    /**
+     * Get recording start time
+     * @returns Start timestamp or null
+     */
+    getStartTime(): number | null;
+    /**
+     * Get elapsed recording time in milliseconds
+     * @returns Elapsed time in ms
+     */
+    getElapsedTime(): number;
+    /**
+     * Get combined audio data
+     * @returns Concatenated Float32Array
+     */
+    private getCombinedAudio;
+    /**
+     * Create a Blob from the recording
+     * @param format - Output format
+     * @returns Blob with audio data
+     */
+    toBlob(format?: AudioFormat): Blob;
+    /**
+     * Create a data URL from the recording
+     * @param format - Output format
+     * @returns Data URL string
+     */
+    toDataURL(format?: AudioFormat): string;
+    /**
+     * Download the recording
+     * @param filename - Output filename
+     * @param format - Output format
+     */
+    download(filename?: string, format?: AudioFormat): void;
+}
+
+/**
+ * Interface for storage adapters
+ * Provides abstraction for different storage backends
+ */
+interface StorageAdapter {
+    /**
+     * Save data to storage
+     * @param key - Storage key
+     * @param data - Data to store
+     */
+    save(key: string, data: unknown): Promise<void>;
+    /**
+     * Load data from storage
+     * @param key - Storage key
+     * @returns Stored data or null if not found
+     */
+    load(key: string): Promise<unknown | null>;
+    /**
+     * Delete data from storage
+     * @param key - Storage key
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * List all keys in storage
+     * @returns Array of keys
+     */
+    list(): Promise<string[]>;
+    /**
+     * Check if key exists in storage
+     * @param key - Storage key
+     * @returns True if key exists
+     */
+    exists(key: string): Promise<boolean>;
+}
+/**
+ * Storage adapter using browser localStorage
+ * Suitable for small data (<5MB)
+ */
+declare class LocalStorageAdapter implements StorageAdapter {
+    /** Prefix for all keys */
+    private prefix;
+    /**
+     * Create a new LocalStorageAdapter
+     * @param prefix - Key prefix (default: 'live-transcribe')
+     */
+    constructor(prefix?: string);
+    /**
+     * Get prefixed key
+     */
+    private getKey;
+    save(key: string, data: unknown): Promise<void>;
+    load(key: string): Promise<unknown | null>;
+    delete(key: string): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+}
+/**
+ * In-memory storage adapter
+ * Useful for testing or temporary storage
+ */
+declare class MemoryStorageAdapter implements StorageAdapter {
+    private storage;
+    save(key: string, data: unknown): Promise<void>;
+    load(key: string): Promise<unknown | null>;
+    delete(key: string): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+    /**
+     * Get storage size
+     */
+    size(): number;
+}
+
+/**
+ * Session data for JSON export
+ */
+interface SessionData$4 {
+    metadata: SessionMetadata;
+    transcripts: TranscriptionResult[];
+}
+/**
+ * Exports transcription sessions to JSON format
+ */
+declare class JSONExporter {
+    /**
+     * Export session to minified JSON string
+     * @param session - Session data to export
+     * @returns JSON string
+     */
+    static export(session: SessionData$4): string;
+    /**
+     * Export session to formatted/pretty JSON string
+     * @param session - Session data to export
+     * @param indent - Indentation spaces (default: 2)
+     * @returns Formatted JSON string
+     */
+    static exportPretty(session: SessionData$4, indent?: number): string;
+    /**
+     * Parse JSON and validate structure
+     * @param json - JSON string to parse
+     * @returns Parsed session export data
+     */
+    static parse(json: string): SessionExportData;
+}
+
+/**
+ * Session data for text export
+ */
+interface SessionData$3 {
+    transcripts: TranscriptionResult[];
+}
+/**
+ * Exports transcription sessions to plain text format
+ */
+declare class TextExporter {
+    /**
+     * Export session transcripts to plain text
+     * @param session - Session data to export
+     * @param options - Export options
+     * @returns Plain text string
+     */
+    static export(session: SessionData$3, options?: TextExportOptions): string;
+    /**
+     * Export as continuous text without any formatting
+     * @param session - Session data to export
+     * @returns Plain text string
+     */
+    static exportPlain(session: SessionData$3): string;
+}
+
+/**
+ * Session data for SRT export
+ */
+interface SessionData$2 {
+    transcripts: TranscriptionResult[];
+}
+/**
+ * Exports transcription sessions to SRT (SubRip) subtitle format
+ */
+declare class SRTExporter {
+    /**
+     * Export session transcripts to SRT format
+     * @param session - Session data to export
+     * @returns SRT formatted string
+     */
+    static export(session: SessionData$2): string;
+    /**
+     * Format milliseconds to SRT timestamp format (HH:MM:SS,mmm)
+     * @param ms - Time in milliseconds
+     * @returns Formatted timestamp
+     */
+    private static formatTime;
+    /**
+     * Pad number with leading zeros
+     * @param num - Number to pad
+     * @param length - Target length
+     * @returns Padded string
+     */
+    private static pad;
+}
+
+/**
+ * Session data for VTT export
+ */
+interface SessionData$1 {
+    transcripts: TranscriptionResult[];
+}
+/**
+ * Exports transcription sessions to WebVTT subtitle format
+ */
+declare class VTTExporter {
+    /**
+     * Export session transcripts to WebVTT format
+     * @param session - Session data to export
+     * @returns WebVTT formatted string
+     */
+    static export(session: SessionData$1): string;
+    /**
+     * Export with cue identifiers
+     * @param session - Session data to export
+     * @param cuePrefix - Prefix for cue identifiers
+     * @returns WebVTT formatted string with cue IDs
+     */
+    static exportWithCues(session: SessionData$1, cuePrefix?: string): string;
+    /**
+     * Format milliseconds to WebVTT timestamp format (HH:MM:SS.mmm)
+     * @param ms - Time in milliseconds
+     * @returns Formatted timestamp
+     */
+    private static formatTime;
+    /**
+     * Pad number with leading zeros
+     */
+    private static pad;
+}
+
+/**
+ * Session data for CSV export
+ */
+interface SessionData {
+    transcripts: TranscriptionResult[];
+}
+/**
+ * Exports transcription sessions to CSV format
+ */
+declare class CSVExporter {
+    /**
+     * Export session transcripts to CSV format
+     * @param session - Session data to export
+     * @param options - Export options
+     * @returns CSV formatted string
+     */
+    static export(session: SessionData, options?: CSVExportOptions): string;
+    /**
+     * Export only final transcripts
+     * @param session - Session data to export
+     * @param options - Export options
+     * @returns CSV formatted string
+     */
+    static exportFinalOnly(session: SessionData, options?: CSVExportOptions): string;
+    /**
+     * Get field value from transcript
+     * @param transcript - Transcription result
+     * @param field - Field name
+     * @returns Field value
+     */
+    private static getFieldValue;
+    /**
+     * Escape field for CSV format
+     * @param field - Field value
+     * @param delimiter - CSV delimiter
+     * @returns Escaped field
+     */
+    private static escapeField;
+}
+
+/**
+ * Validation error details
+ */
+interface ValidationError {
+    /** Field that failed validation */
+    field: string;
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: string;
+}
+/**
+ * Validation warning details
+ */
+interface ValidationWarning {
+    /** Field with warning */
+    field: string;
+    /** Warning message */
+    message: string;
+}
+/**
+ * Result of validation
+ */
+interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** List of errors */
+    errors: ValidationError[];
+    /** List of warnings */
+    warnings?: ValidationWarning[];
+}
+/**
+ * Validate transcription configuration
+ * @param config - Configuration to validate
+ * @returns Validation result
+ */
+declare function validateTranscriptionConfig(config: TranscriptionConfig): ValidationResult;
+/**
+ * Validate audio configuration
+ * @param config - Audio config to validate
+ * @returns Validation result
+ */
+declare function validateAudioConfig(config: AudioConfig): ValidationResult;
+/**
+ * Validate session configuration
+ * @param config - Session config to validate
+ * @returns Validation result
+ */
+declare function validateSessionConfig(config: SessionConfig): ValidationResult;
+/**
+ * Validate BCP-47 language code
+ * @param code - Language code to validate
+ * @returns True if valid
+ */
+declare function validateLanguageCode(code: string): boolean;
+/**
+ * Validate API key format for a provider
+ * @param provider - Transcription provider
+ * @param key - API key to validate
+ * @returns Validation result
+ */
+declare function validateApiKey(provider: TranscriptionProvider, key?: string): ValidationResult;
+
+/**
+ * Browser information
+ */
+interface BrowserInfo {
+    /** Browser name */
+    name: string;
+    /** Browser version */
+    version: string;
+    /** Operating system */
+    os: string;
+    /** Whether device is mobile */
+    isMobile: boolean;
+}
+/**
+ * Support check result
+ */
+interface SupportCheck {
+    /** Whether feature is supported */
+    supported: boolean;
+    /** Details about support status */
+    details: string;
+    /** Fallback recommendation if not supported */
+    fallback?: string;
+}
+/**
+ * Full compatibility report
+ */
+interface CompatibilityReport {
+    /** Browser information */
+    browser: BrowserInfo;
+    /** Web Speech API support */
+    webSpeechAPI: SupportCheck;
+    /** WebSocket support */
+    webSocket: SupportCheck;
+    /** Media devices support */
+    mediaDevices: SupportCheck;
+    /** Audio context support */
+    audioContext: SupportCheck;
+    /** Overall compatibility */
+    overallCompatible: boolean;
+    /** Recommendations for improvement */
+    recommendations: string[];
+}
+/**
+ * Get browser information
+ * @returns Browser info object
+ */
+declare function getBrowserInfo(): BrowserInfo;
+/**
+ * Check Web Speech API support
+ * @returns Support check result
+ */
+declare function checkWebSpeechAPISupport(): SupportCheck;
+/**
+ * Check WebSocket support
+ * @returns Support check result
+ */
+declare function checkWebSocketSupport(): SupportCheck;
+/**
+ * Check media devices support
+ * @returns Support check result
+ */
+declare function checkMediaDevicesSupport(): SupportCheck;
+/**
+ * Check AudioContext support
+ * @returns Support check result
+ */
+declare function checkAudioContextSupport(): SupportCheck;
+/**
+ * Get comprehensive compatibility report
+ * @returns Full compatibility report
+ */
+declare function getFullCompatibilityReport(): CompatibilityReport;
+
+/**
+ * Retry options
+ */
+interface RetryOptions {
+    /** Maximum number of attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in ms (default: 1000) */
+    delay?: number;
+    /** Backoff strategy (default: 'exponential') */
+    backoff?: 'linear' | 'exponential';
+    /** Maximum delay in ms (default: 30000) */
+    maxDelay?: number;
+    /** Function to determine if should retry */
+    shouldRetry?: (error: unknown) => boolean;
+}
+/**
+ * Create a debounced function
+ * @param func - Function to debounce
+ * @param wait - Wait time in ms
+ * @returns Debounced function
+ */
+declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Create a throttled function
+ * @param func - Function to throttle
+ * @param limit - Minimum interval in ms
+ * @returns Throttled function
+ */
+declare function throttle<T extends (...args: unknown[]) => unknown>(func: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * Async sleep utility
+ * @param ms - Milliseconds to sleep
+ * @returns Promise that resolves after delay
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Add timeout to a promise
+ * @param promise - Promise to wrap
+ * @param ms - Timeout in milliseconds
+ * @param message - Error message on timeout
+ * @returns Promise that rejects if timeout exceeded
+ */
+declare function timeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+/**
+ * Retry a function with backoff
+ * @param fn - Async function to retry
+ * @param options - Retry options
+ * @returns Promise with result
+ */
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Create a cancellable timeout
+ * @param ms - Timeout in milliseconds
+ * @returns Object with promise and cancel function
+ */
+declare function cancellableTimeout(ms: number): {
+    promise: Promise<void>;
+    cancel: () => void;
+};
+/**
+ * Execute function at regular intervals
+ * @param fn - Function to execute
+ * @param interval - Interval in ms
+ * @param immediate - Execute immediately on start
+ * @returns Function to stop the interval
+ */
+declare function setIntervalAsync(fn: () => Promise<void>, interval: number, immediate?: boolean): () => void;
+
+/**
+ * Timestamp format options
+ */
+type TimestampFormat = 'srt' | 'vtt' | 'readable' | 'iso' | 'ms';
+/**
+ * Display options for transcript formatting
+ */
+interface DisplayOptions {
+    /** Show timestamps */
+    showTimestamps?: boolean;
+    /** Show confidence scores */
+    showConfidence?: boolean;
+    /** Highlight interim results */
+    highlightInterim?: boolean;
+    /** Maximum text length */
+    maxLength?: number;
+}
+/**
+ * Format duration in milliseconds to readable string
+ * @param ms - Duration in milliseconds
+ * @returns Formatted string (e.g., "2m 30s")
+ */
+declare function formatDuration(ms: number): string;
+/**
+ * Format timestamp to specified format
+ * @param ms - Time in milliseconds
+ * @param format - Output format
+ * @returns Formatted timestamp
+ */
+declare function formatTimestamp(ms: number, format?: TimestampFormat): string;
+/**
+ * Format confidence score as percentage
+ * @param confidence - Confidence value (0-1)
+ * @returns Formatted percentage string
+ */
+declare function formatConfidence(confidence: number): string;
+/**
+ * Format file size in bytes to human-readable string
+ * @param bytes - Size in bytes
+ * @returns Formatted size string
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Format transcripts for display
+ * @param results - Transcription results
+ * @param options - Display options
+ * @returns Formatted string
+ */
+declare function formatTranscriptForDisplay(results: TranscriptionResult[], options?: DisplayOptions): string;
+/**
+ * Format transcript as plain text
+ * @param results - Transcription results
+ * @param finalOnly - Only include final results
+ * @returns Plain text string
+ */
+declare function formatAsPlainText(results: TranscriptionResult[], finalOnly?: boolean): string;
+/**
+ * Format number with thousand separators
+ * @param num - Number to format
+ * @returns Formatted string
+ */
+declare function formatNumber(num: number): string;
+/**
+ * Truncate text with ellipsis
+ * @param text - Text to truncate
+ * @param maxLength - Maximum length
+ * @returns Truncated text
+ */
+declare function truncateText(text: string, maxLength: number): string;
+
+/**
+ * Language information
+ */
+interface LanguageInfo {
+    /** Language code (e.g., 'en-US') */
+    code: string;
+    /** English name */
+    name: string;
+    /** Native name */
+    nativeName: string;
+    /** Provider that supports this language */
+    provider: TranscriptionProvider;
+}
+/**
+ * Get supported languages for a provider
+ * @param provider - Transcription provider
+ * @returns Array of language info
+ */
+declare function getSupportedLanguages(provider: TranscriptionProvider): LanguageInfo[];
+/**
+ * Normalize language code to standard format
+ * @param code - Language code to normalize
+ * @returns Normalized code
+ */
+declare function normalizeLanguageCode(code: string): string;
+/**
+ * Get human-readable language name
+ * @param code - Language code
+ * @returns Language name or code if unknown
+ */
+declare function getLanguageName(code: string): string;
+/**
+ * Get native language name
+ * @param code - Language code
+ * @returns Native name or code if unknown
+ */
+declare function getNativeLanguageName(code: string): string;
+/**
+ * Detect browser language
+ * @returns Detected language code
+ */
+declare function detectBrowserLanguage(): string;
+/**
+ * Check if language is supported by provider
+ * @param code - Language code
+ * @param provider - Transcription provider
+ * @returns True if supported
+ */
+declare function isLanguageSupported(code: string, provider: TranscriptionProvider): boolean;
+/**
+ * Get best matching language for provider
+ * @param code - Preferred language code
+ * @param provider - Transcription provider
+ * @returns Best matching language code or default
+ */
+declare function getBestMatchingLanguage(code: string, provider: TranscriptionProvider): string;
+
+/**
+ * Generate a unique ID
+ * @param prefix - Optional prefix
+ * @returns Unique ID string
+ */
+declare function generateId(prefix?: string): string;
+/**
+ * Deep clone an object
+ * @param obj - Object to clone
+ * @returns Cloned object
+ */
+declare function deepClone<T>(obj: T): T;
+/**
+ * Deep merge multiple objects
+ * @param objects - Objects to merge
+ * @returns Merged object
+ */
+declare function mergeDeep<T extends Record<string, unknown>>(...objects: Partial<T>[]): T;
+/**
+ * Check if value is a function
+ * @param value - Value to check
+ * @returns True if function
+ */
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Check if value is a plain object
+ * @param value - Value to check
+ * @returns True if object
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Check if value is empty
+ * @param value - Value to check
+ * @returns True if empty
+ */
+declare function isEmpty(value: unknown): boolean;
+/**
+ * Pick specific properties from object
+ * @param obj - Source object
+ * @param keys - Keys to pick
+ * @returns New object with selected keys
+ */
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Omit specific properties from object
+ * @param obj - Source object
+ * @param keys - Keys to omit
+ * @returns New object without selected keys
+ */
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Create a promise that resolves after a condition is met
+ * @param condition - Function that returns true when condition is met
+ * @param interval - Check interval in ms
+ * @param timeout - Maximum wait time in ms
+ * @returns Promise that resolves when condition is met
+ */
+declare function waitFor(condition: () => boolean, interval?: number, timeout?: number): Promise<void>;
+/**
+ * Group array items by key
+ * @param array - Array to group
+ * @param keyFn - Function to get key from item
+ * @returns Grouped object
+ */
+declare function groupBy<T, K extends string | number>(array: T[], keyFn: (item: T) => K): Record<K, T[]>;
+/**
+ * Ensure value is within range
+ * @param value - Value to clamp
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Clamped value
+ */
+declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Round number to specified decimal places
+ * @param value - Number to round
+ * @param decimals - Number of decimal places
+ * @returns Rounded number
+ */
+declare function round(value: number, decimals?: number): number;
+
+/**
+ * Audio format information
+ */
+interface AudioFormatInfo {
+    /** Detected format */
+    format: string;
+    /** Sample rate in Hz */
+    sampleRate?: number;
+    /** Number of channels */
+    channels?: number;
+    /** Bit depth */
+    bitDepth?: number;
+    /** Duration in seconds */
+    duration?: number;
+}
+/**
+ * Calculate audio bitrate
+ * @param sampleRate - Sample rate in Hz
+ * @param bitDepth - Bits per sample
+ * @param channels - Number of channels
+ * @returns Bitrate in bits per second
+ */
+declare function calculateBitrate(sampleRate: number, bitDepth: number, channels: number): number;
+/**
+ * Estimate audio file size
+ * @param durationMs - Duration in milliseconds
+ * @param config - Audio configuration
+ * @returns Estimated size in bytes
+ */
+declare function estimateAudioSize(durationMs: number, config: AudioConfig): number;
+/**
+ * Get optimal buffer size for sample rate
+ * @param sampleRate - Sample rate in Hz
+ * @returns Optimal buffer size (power of 2)
+ */
+declare function getOptimalBufferSize(sampleRate: number): number;
+/**
+ * Validate and detect audio format from ArrayBuffer
+ * @param data - Audio data
+ * @returns Audio format information
+ */
+declare function validateAudioFormat(data: ArrayBuffer): AudioFormatInfo;
+/**
+ * Calculate RMS (Root Mean Square) of audio buffer
+ * @param buffer - Audio samples
+ * @returns RMS value (0-1)
+ */
+declare function calculateRMS(buffer: Float32Array): number;
+/**
+ * Calculate peak amplitude of audio buffer
+ * @param buffer - Audio samples
+ * @returns Peak value (0-1)
+ */
+declare function calculatePeak(buffer: Float32Array): number;
+/**
+ * Convert decibels to linear amplitude
+ * @param db - Value in decibels
+ * @returns Linear amplitude
+ */
+declare function dbToLinear(db: number): number;
+/**
+ * Convert linear amplitude to decibels
+ * @param linear - Linear amplitude
+ * @returns Value in decibels
+ */
+declare function linearToDb(linear: number): number;
+/**
+ * Check if audio data contains silence
+ * @param buffer - Audio samples
+ * @param threshold - Silence threshold (default: 0.001)
+ * @returns True if mostly silence
+ */
+declare function isSilence(buffer: Float32Array, threshold?: number): boolean;
+/**
+ * Get audio constraints for getUserMedia
+ * @param config - Audio configuration
+ * @returns MediaStreamConstraints for audio
+ */
+declare function getAudioConstraints(config?: AudioConfig): MediaTrackConstraints;
+/**
+ * Calculate audio duration from samples
+ * @param samples - Number of samples
+ * @param sampleRate - Sample rate in Hz
+ * @returns Duration in milliseconds
+ */
+declare function samplesToDuration(samples: number, sampleRate: number): number;
+/**
+ * Calculate samples from duration
+ * @param durationMs - Duration in milliseconds
+ * @param sampleRate - Sample rate in Hz
+ * @returns Number of samples
+ */
+declare function durationToSamples(durationMs: number, sampleRate: number): number;
+
+/**
+ * Live Transcribe - Professional live speech transcription library
+ * @module live-transcribe
+ */
+
+/**
+ * Library version
+ */
+declare const VERSION = "0.1.0";
+/**
+ * Library name
+ */
+declare const LIBRARY_NAME = "live-transcribe";
+/**
+ * Quick start options for simplified initialization
+ */
+interface QuickStartOptions {
+    /** Transcription provider (default: auto-detect) */
+    provider?: TranscriptionProvider;
+    /** API key for cloud providers */
+    apiKey?: string;
+    /** Language code (default: 'en-US') */
+    language?: string;
+    /** Callback for transcript events */
+    onTranscript?: (result: TranscriptionResult) => void;
+    /** Callback for error events */
+    onError?: (error: TranscriptionError) => void;
+    /** Callback when transcription starts */
+    onStart?: () => void;
+    /** Callback when transcription stops */
+    onStop?: () => void;
+    /** Enable interim results (default: true) */
+    interimResults?: boolean;
+    /** Enable audio recording */
+    recordAudio?: boolean;
+}
+/**
+ * Create a transcription provider instance
+ * @param config - Transcription configuration
+ * @returns Configured provider instance
+ * @example
+ * ```typescript
+ * const provider = createTranscriber({
+ *   provider: TranscriptionProvider.WebSpeechAPI,
+ *   language: 'en-US'
+ * });
+ * ```
+ */
+declare function createTranscriber(config: TranscriptionConfig): ITranscriptionProvider;
+/**
+ * Create a transcription session with a configured provider
+ * @param config - Transcription configuration
+ * @param sessionConfig - Optional session configuration
+ * @returns Configured TranscriptionSession
+ * @example
+ * ```typescript
+ * const session = createSession({
+ *   provider: TranscriptionProvider.Deepgram,
+ *   apiKey: 'your-api-key',
+ *   language: 'en-US'
+ * }, {
+ *   recordAudio: true
+ * });
+ * ```
+ */
+declare function createSession(config: TranscriptionConfig, sessionConfig?: SessionConfig): TranscriptionSession;
+/**
+ * Quick start transcription with minimal configuration
+ * Auto-detects the best available provider and handles initialization
+ * @param options - Quick start options
+ * @returns Ready-to-use TranscriptionSession
+ * @example
+ * ```typescript
+ * const session = await quickStart({
+ *   language: 'en-US',
+ *   onTranscript: (result) => console.log(result.text),
+ *   onError: (error) => console.error(error)
+ * });
+ *
+ * // Session is already started and transcribing
+ * // Stop when done:
+ * await session.stop();
+ * ```
+ */
+declare function quickStart(options?: QuickStartOptions): Promise<TranscriptionSession>;
+/**
+ * Check if a specific provider is supported in the current environment
+ * @param provider - Provider to check
+ * @returns True if provider is supported
+ */
+declare function isProviderSupported(provider: TranscriptionProvider): boolean;
+/**
+ * Get list of supported providers in current environment
+ * @returns Array of supported providers
+ */
+declare function getSupportedProviders(): TranscriptionProvider[];
+declare const _default: {
+    VERSION: string;
+    LIBRARY_NAME: string;
+    createTranscriber: typeof createTranscriber;
+    createSession: typeof createSession;
+    quickStart: typeof quickStart;
+    isProviderSupported: typeof isProviderSupported;
+    getSupportedProviders: typeof getSupportedProviders;
+    TranscriptionProvider: typeof TranscriptionProvider;
+    WebSpeechProvider: typeof WebSpeechProvider;
+    DeepgramProvider: typeof DeepgramProvider;
+    AssemblyAIProvider: typeof AssemblyAIProvider;
+    TranscriptionSession: typeof TranscriptionSession;
+    SessionManager: typeof SessionManager;
+};
+
+export { type AssemblyAIOptions, AssemblyAIProvider, AudioBufferManager, type AudioConfig, AudioEncoding, type AudioFormat, type AudioFormatInfo, AudioLevelMonitor, type AudioLevelMonitorOptions, AudioProcessor, AudioRecorder, BaseTranscriber, type BrowserInfo, type CSVExportOptions, CSVExporter, type CompatibilityReport, DEFAULT_AUDIO_CONFIG, DEFAULT_SESSION_CONFIG, DEFAULT_TRANSCRIPTION_CONFIG, type DeepgramOptions, DeepgramProvider, type DisplayOptions, ErrorCode, EventEmitter, type ExportFormat, type ExportResult, type ITranscriptionProvider, JSONExporter, LIBRARY_NAME, type LanguageInfo, LocalStorageAdapter, MemoryStorageAdapter, type MergeOptions, type ProviderCapabilities, type ProviderInfo, type QuickStartOptions, type RetryOptions, SRTExporter, type SessionConfig, type SessionExport, type SessionExportData, type SessionImport, SessionManager, type SessionManagerOptions, type SessionMetadata, SessionState, type SessionStatistics, type SessionStats, type StorageAdapter, type SupportCheck, type TextExportOptions, TextExporter, type TimestampFormat, type TranscriptionConfig, TranscriptionError, type TranscriptionEventName, type TranscriptionEvents, TranscriptionProvider, type TranscriptionResult, type TranscriptionSegment, TranscriptionSession, type VADOptions, VERSION, VTTExporter, type ValidationError, type ValidationResult, type ValidationWarning, VoiceActivityDetector, WebSpeechProvider, type Word, calculateBitrate, calculatePeak, calculateRMS, cancellableTimeout, checkAudioContextSupport, checkMediaDevicesSupport, checkWebSocketSupport, checkWebSpeechAPISupport, clamp, createSession, createTranscriber, dbToLinear, debounce, deepClone, _default as default, detectBrowserLanguage, durationToSamples, estimateAudioSize, formatAsPlainText, formatConfidence, formatDuration, formatFileSize, formatNumber, formatTimestamp, formatTranscriptForDisplay, generateId, getAudioConstraints, getBestMatchingLanguage, getBrowserInfo, getFullCompatibilityReport, getLanguageName, getNativeLanguageName, getOptimalBufferSize, getSupportedLanguages, getSupportedProviders, groupBy, isEmpty, isFunction, isLanguageSupported, isObject, isProviderSupported, isSilence, linearToDb, mergeDeep, normalizeLanguageCode, omit, pick, quickStart, retry, round, samplesToDuration, setIntervalAsync, sleep, throttle, timeout, truncateText, validateApiKey, validateAudioConfig, validateAudioFormat, validateLanguageCode, validateSessionConfig, validateTranscriptionConfig, waitFor };