import { type MediaPlayer } from './mediaPlayer';
type AudioChunk = {
    sampleRate: number;
    buffer: Float32Array;
};
/**
 * An internal object used to manage an active audio stream.
 */
declare class AudioStream {
    private readonly context;
    readonly destNode: MediaStreamAudioDestinationNode;
    private readonly outputNode;
    private readonly analyzerNode;
    private nextSeqNum;
    private playing;
    constructor(context: AudioContext);
    get stream(): MediaStream;
    get streamId(): string;
    get analyzer(): AnalyserNode;
    appendBuffer(chunk: AudioChunk): void;
    close(): void;
    advance(): void;
    pause(): void;
    resume(): void;
    onPlaying?: (streamId: string) => void;
    onWaiting?: (streamId: string) => void;
    /**
     * Appends PCM audio data to the output node, converting and resampling if necessary.
     */
    private appendPcmBuffer;
    /**
     * Resamples PCM audio data to the output node's sample rate, converting to f32 if necessary.
     */
    private resamplePcmBuffer;
    /**
     * Appends f32 PCM audio data (with the correct sample rate) to the output node.
     */
    private appendNativeBuffer;
    private handleBufferProcessed;
}
/**
 * Manages an AudioContext and allows creation of multiple audio streams
 * that can be played out using <audio> elements. Use of <audio> for
 * playout avoids some of the problems associated with using WebAudio
 * directly, e.g., audio not playing on iOS when the phone is on silent.
 */
export declare class AudioOutputManager extends EventTarget {
    private context?;
    private readonly streams;
    start(): Promise<void>;
    stop(): void;
    createStream(): MediaStream;
    destroyStream(streamId: string): void;
    advanceStream(streamId: string): void;
    pauseStream(streamId: string): void;
    resumeStream(streamId: string): void;
    getAudioStream(streamId: string): AudioStream;
    getAnalyzer(streamId: string): AnalyserNode;
    getMediaStreamDestNode(streamId: string): MediaStreamAudioDestinationNode;
    appendBuffer(streamId: string, chunk: AudioChunk): void;
    private handleStreamStateChange;
}
export declare class Mp3Decoder {
    private onData;
    private onError;
    private readonly decoder;
    private readonly decoderReadyPromise;
    constructor(onData: (audioChunk: AudioChunk) => void, onError: (error: Error) => void);
    addData(encodedBuffer: ArrayBuffer): Promise<void>;
    reset(): Promise<void>;
    free(): void;
}
/**
 * Defines a text-to-speech service that requests individual audio utterances
 * from a server and plays them out using Web Audio and <audio> elements.
 * This approach reduces latency by allowing the audio to be streamed as it is
 * generated, rather than waiting for the entire audio file to be generated. It also
 * allows text to be fed to the service in a stream rather than all at once.
 */
export declare class AudioContextPlayer implements MediaPlayer {
    private isPlaying;
    private waitingForAudio;
    private ignoreFirstWaiting;
    private streamId;
    private readonly audio;
    private outputManager;
    private onPlay;
    private onStop;
    private onEmpty;
    private mp3Decoder;
    init({ onPlay, onStop, onEmpty }?: {
        onPlay: () => void;
        onStop: () => void;
        onEmpty: () => void;
    }): Promise<void>;
    appendAudioChunk: (audioData: Uint8Array) => void;
    /**
     * A `newAudioStream` indicates the start of a new audio stream. It is recommended to clear your player buffer and
     * start playing the new stream content when this happens.
     */
    advance: () => void;
    protected play(): void;
    pause(): void;
    resume(): void;
    clear(): void;
    get analyserNode(): AnalyserNode;
    get mediaStreamDestNode(): MediaStreamAudioDestinationNode;
    private onWaiting;
    private onPlaying;
    /**
     * Adds a chunk to the pending chunk buffer, and starts processing the buffer, if possible.
     * The chunk can be a placeholder without any data if the data will be added later;
     * this is useful to ensure chunks are played in the correct order.
     */
    protected appendChunk(chunk: AudioChunk): void;
}
export {};