import { VADState } from '../vad';
import { TurnDetectionMode, ClientVADConfig } from '../types';
/**
 * @fileoverview Enhanced VAD Manager - Integrates with VAD Adapter Interface
 *
 * This is an enhanced version of VADManager that supports the new modular
 * VAD adapter interface while maintaining backward compatibility with the
 * existing VADType-based configuration.
 *
 * @module @vowel.to/client/managers
 * @author vowel.to
 * @license Proprietary
 */
declare class EventEmitter {
    private listeners;
    on(event: string, listener: (...args: any[]) => void): this;
    emit(event: string, ...args: any[]): boolean;
    removeAllListeners(event?: string): this;
}
/**
 * Configuration for the enhanced VAD manager
 */
export interface EnhancedVADManagerConfig {
    /**
     * Turn detection mode
     * @default 'client_vad'
     */
    mode?: TurnDetectionMode;
    /**
     * Client VAD configuration (for 'client_vad' mode)
     */
    clientVAD?: ClientVADConfig;
    /**
     * MediaStream for VAD adapters that need direct stream access (e.g., MicVAD/Silero VAD)
     * If not provided, adapters may create their own streams (not ideal)
     */
    mediaStream?: MediaStream;
    /**
     * Rolling buffer configuration for capturing audio around VAD segments
     *
     * Note: With MicVAD (Silero VAD), padding is handled internally by the library.
     * This buffer is mainly for compatibility with other VAD adapters.
     */
    rollingBuffer?: {
        /**
         * Duration of audio to capture before speech detection (in milliseconds)
         * @default 3000
         */
        prefixMs?: number;
        /**
         * Duration of audio to capture after speech ends (in milliseconds)
         * @default 100
         */
        suffixMs?: number;
    };
    /**
     * Enable redundant Simple VAD alongside Silero VAD
     * When enabled, Simple VAD runs in parallel and can pause/cancel Silero VAD
     * if it doesn't detect speech for an extended period while Silero is still detecting speech.
     * @default true for Silero VAD, false otherwise
     */
    enableRedundantSimpleVAD?: boolean;
    /**
     * Duration (in milliseconds) that Simple VAD must not detect speech before
     * pausing/cancelling Silero VAD when Silero is still detecting speech.
     * @default 6000 (6 seconds)
     */
    simpleVADSilenceThresholdMs?: number;
    /**
     * Called when speech is detected
     */
    onSpeechStart?: () => void;
    /**
     * Called when speech ends
     */
    onSpeechEnd?: () => void;
    /**
     * Called when VAD is ready to use
     */
    onVADReady?: () => void;
    /**
     * Called when VAD encounters an error
     */
    onVADError?: (error: Error) => void;
    /**
     * Called when VAD state changes
     */
    onVADStateChange?: (state: VADState) => void;
}
/**
 * Enhanced VAD Manager
 *
 * Supports both legacy VADType configuration and new modular VAD adapters.
 * This class extends EventEmitter to provide event-based communication.
 *
 * Features a rolling buffer to capture audio around VAD segments, ensuring
 * we don't miss speech that occurred before or after the VAD detected segment.
 */
export declare class EnhancedVADManager extends EventEmitter {
    private adapter;
    private simpleVADAdapter;
    private config;
    private mode;
    private isActive;
    private isSpeakingFromEvent;
    private audioBuffer;
    private rollingBuffer;
    private rollingBufferMaxSize;
    private suffixBuffer;
    private suffixBufferMaxSize;
    private collectingSuffix;
    private enableRedundantSimpleVAD;
    private simpleVADSilenceThresholdMs;
    private lastSimpleVADSpeechTime;
    constructor(config?: EnhancedVADManagerConfig);
    /**
     * Initialize VAD based on the configured mode
     */
    initialize(): Promise<void>;
    /**
     * Initialize disabled mode (no VAD)
     */
    private initializeDisabledMode;
    /**
     * Initialize client-side VAD with adapter
     */
    private initializeClientVAD;
    /**
     * Set up event listeners for the VAD adapter
     * Adapters now emit events instead of requiring frame-by-frame state checking
     */
    private setupAdapterEventListeners;
    /**
     * Handle speech start event from adapter
     */
    private handleSpeechStart;
    /**
     * Handle speech end event from adapter
     */
    private handleSpeechEnd;
    /**
     * Process audio frame
     * Called by AudioWorklet for every frame when in client_vad mode
     *
     * This method now only buffers audio. VAD adapters emit events instead of
     * requiring frame-by-frame state checking. The manager listens to adapter events
     * and trims audio accordingly.
     */
    processFrame(frame: Float32Array, timestamp: number): void;
    /**
     * Commit the current audio buffer
     * Called when speech ends (if autoCommit is enabled) or manually
     */
    commitAudioBuffer(): Float32Array | null;
    /**
     * Get current VAD state
     */
    getState(): VADState | null;
    /**
     * Check if VAD is initialized and active
     */
    isInitialized(): boolean;
    /**
     * Check if currently in speech
     */
    isSpeaking(): boolean;
    /**
     * Get current mode
     */
    getMode(): TurnDetectionMode;
    /**
     * Reset VAD state
     */
    reset(): void;
    /**
     * Dispose VAD resources
     */
    dispose(): void;
    /**
     * Pause VAD processing
     */
    pause(): void;
    /**
     * Resume VAD processing
     */
    resume(): void;
}
export interface EnhancedVADManager {
    on(event: 'vad:ready', listener: (data: {
        adapterId: string;
        adapterName: string;
    }) => void): this;
    on(event: 'vad:speech:start', listener: (data: {
        timestamp: number;
        probability: number;
        adapterId: string;
    }) => void): this;
    on(event: 'vad:speech:end', listener: (data: {
        timestamp: number;
        duration: number;
        adapterId: string;
    }) => void): this;
    on(event: 'vad:speech:progress', listener: (data: {
        timestamp: number;
        duration: number;
        probability: number;
        adapterId: string;
    }) => void): this;
    on(event: 'vad:speech:cancelled', listener: (data: {
        timestamp: number;
        reason: string;
        adapterId: string;
    }) => void): this;
    on(event: 'vad:state:change', listener: (data: {
        previousState: VADState;
        currentState: VADState;
        adapterId: string;
    }) => void): this;
    on(event: 'vad:error', listener: (data: {
        error: Error;
        adapterId?: string;
        recoverable: boolean;
    }) => void): this;
    on(event: 'audio:commit', listener: (data: {
        audio: Float32Array;
    }) => void): this;
    emit(event: 'vad:ready', data: {
        adapterId: string;
        adapterName: string;
    }): boolean;
    emit(event: 'vad:speech:start', data: {
        timestamp: number;
        probability: number;
        adapterId: string;
    }): boolean;
    emit(event: 'vad:speech:end', data: {
        timestamp: number;
        duration: number;
        adapterId: string;
    }): boolean;
    emit(event: 'vad:speech:progress', data: {
        timestamp: number;
        duration: number;
        probability: number;
        adapterId: string;
    }): boolean;
    emit(event: 'vad:speech:cancelled', data: {
        timestamp: number;
        reason: string;
        adapterId: string;
    }): boolean;
    emit(event: 'vad:state:change', data: {
        previousState: VADState;
        currentState: VADState;
        adapterId: string;
    }): boolean;
    emit(event: 'vad:error', data: {
        error: Error;
        adapterId?: string;
        recoverable: boolean;
    }): boolean;
    emit(event: 'audio:commit', data: {
        audio: Float32Array;
    }): boolean;
}
export {};
//# sourceMappingURL=EnhancedVADManager.d.ts.map