import { DecoderState, DecoderOptions, ContextOptions, AudioProcessorParameters, StreamOptions } from './types';
import { Segment, Word, Entity, Intent } from '../speechly';
/**
 * Speechly BrowserClient streams audio containing speech for cloud processing and
 * provides the results of automatic speech recogition (ASR) and natural langugage understanding (NLU) via callbacks.
 *
 * Usage:
 *
 * - Create a BrowserClient instance with {@link DecoderOptions} containing a valid appId from https://api.speechly.com/dashboard.
 * - Create and initialize a {@link BrowserMicrophone} instance and {@link attach} its mediaStream to the BrowserClient instance.
 * - Control processing manually with {@link start} and {@link stop}. Alternatively, you can enable automatic control by initializing BrowserClient with {@link VadOptions} defined in the {@link DecoderOptions}.
 * - Read the ASR/NLU result {@link Segment} by providing a custom handler for the {@link onSegmentChange} callback.
 *
 * Alternatively, you can create the BrowserClient instance and process audio files (binary data) using {@link uploadAudioData}.
 * @public
 */
export declare class BrowserClient {
    private readonly contextStopDelay;
    private readonly nativeResamplingSupported;
    private readonly debug;
    private readonly useSAB;
    private readonly isSafari;
    private readonly isMobileSafari;
    private readonly decoder;
    private readonly callbacks;
    private audioContext?;
    private initialized;
    private audioProcessorInitialized;
    private isStreaming;
    private active;
    private speechlyNode?;
    private audioProcessor?;
    private stream?;
    private listeningPromise;
    private readonly decoderOptions;
    private streamOptions;
    private stats;
    /**
     * Create a new BrowserClient instance.
     *
     * @param customOptions - any custom options for BrowserClient and the enclosed CloudDecoder.
     */
    constructor(customOptions: DecoderOptions);
    /**
     * Connect to cloud, create an AudioContext for receiving audio samples from a MediaStream
     * and initialize a worker for audio processing and bi-directional streaming to the cloud.
     */
    initialize(options?: {
        mediaStream?: MediaStream;
    }): Promise<void>;
    /**
     * Attach a MediaStream to the client, enabling the client to send the audio to the
     * Speechly API for processing. The processing is activated by calling
     * {@link BrowserClient.start} and deactivated by calling {@link BrowserClient.stop}.
     */
    attach(mediaStream: MediaStream): Promise<void>;
    /**
     * @returns Whether the client is processing audio at the moment.
     */
    isActive(): boolean;
    /**
     * Starts a new audio context, returning it's id to use for matching received responses.
     * If an active context already exists, an error is thrown.
     *
     * @param options - any custom options for the audio processing.
     * @returns The contextId of the active audio context
     */
    start(options?: ContextOptions): Promise<string>;
    /**
     * Stops the current audio context and deactivates the audio processing pipeline.
     * If there is no active audio context, a warning is logged to console.
     */
    stop(stopDelayMs?: number): Promise<string>;
    /**
     * Sets the default context options (appId, inference parameters, timezone). New audio contexts
     * use these options until new options are provided. Decoder's functions startContext() can
     * also override the options per function call.
     */
    setContextOptions(options: ContextOptions): Promise<void>;
    /**
     * Control audio processor parameters like VAD
     * @param ap - Audio processor parameters to adjust
     */
    adjustAudioProcessor(ap: AudioProcessorParameters): void;
    /**
     * Upload an audio binary (like .wav) to the cloud for automatic speech recogition (ASR) and natural langugage understanding (NLU).
     * Callbacks are fired as the processing advances.
     *
     * @param audioData - audio data in a binary format. Will be decoded.
     * @param options - any custom options for the audio processing.
     * @returns array of segments containing the final results of speech recognition (ASR and NLU).
     */
    uploadAudioData(audioData: ArrayBuffer, options?: ContextOptions): Promise<Segment[]>;
    /**
     * `startStream` is used to indicate start of continuous audio stream.
     * It resets the stream sample counters and history.
     * BrowserClient internally calls `startStream` upon `initialize` and `start` so it's not needed unless you've manually called `stopStream` and want to resume audio processing afterwards.
     * @param streamOptionOverrides - options for stream processing
     */
    startStream(streamOptionOverrides?: Partial<StreamOptions>): Promise<void>;
    /**
     * `stopStream` is used to indicate end of continuous audio stream.
     * It ensures that all of the internal audio buffers are flushed for processing.
     * BrowserClient internally calls `stopStream` upon `stop` so it's not needed unless then source audio stream is no longer available or you manually want to pause audio processing.
     * Use `startStream` to resume audio processing afterwards.
     */
    stopStream(): Promise<void>;
    private queueTask;
    private autoControlListening;
    private autoControlStream;
    private handleStateChange;
    /**
     * Detach or disconnect the client from the audio source.
     */
    detach(): Promise<void>;
    /**
     * Closes the client, detaching from any audio source and disconnecting any audio
     * processors.
     */
    close(): Promise<void>;
    private sleep;
    private handleAudio;
    /**
     * Adds a listener for start events
     * @param cb - the callback to invoke on context start
     */
    onStart(cb: (contextId: string) => void): void;
    /**
     * Adds a listener for stop events
     * @param cb - the callback to invoke on context stop
     */
    onStop(cb: (contextId: string) => void): void;
    /**
     * Adds a listener for current segment change events.
     * @param cb - the callback to invoke on segment change events.
     */
    onSegmentChange(cb: (segment: Segment) => void): void;
    /**
     * Adds a listener for transcript responses from the API.
     * @param cb - the callback to invoke on a transcript response.
     */
    onTranscript(cb: (contextId: string, segmentId: number, word: Word) => void): void;
    /**
     * Adds a listener for entity responses from the API.
     * @param cb - the callback to invoke on an entity response.
     */
    onEntity(cb: (contextId: string, segmentId: number, entity: Entity) => void): void;
    /**
     * Adds a listener for intent responses from the API.
     * @param cb - the callback to invoke on an intent response.
     */
    onIntent(cb: (contextId: string, segmentId: number, intent: Intent) => void): void;
    /**
     * Adds a listener for tentative transcript responses from the API.
     * @param cb - the callback to invoke on a tentative transcript response.
     */
    onTentativeTranscript(cb: (contextId: string, segmentId: number, words: Word[], text: string) => void): void;
    /**
     * Adds a listener for tentative entities responses from the API.
     * @param cb - the callback to invoke on a tentative entities response.
     */
    onTentativeEntities(cb: (contextId: string, segmentId: number, entities: Entity[]) => void): void;
    /**
     * Adds a listener for tentative intent responses from the API.
     * @param cb - the callback to invoke on a tentative intent response.
     */
    onTentativeIntent(cb: (contextId: string, segmentId: number, intent: Intent) => void): void;
    /**
     * Adds a listener for the state changes of the client.
     * @param cb - the callback to invoke on a client state change.
     */
    onStateChange(cb: (state: DecoderState) => void): void;
}