import type { MoonshineAssetModelConfig, MoonshineCancelTranscriptionResult, MoonshineCreateIntentRecognizerConfig, MoonshineInitializeResult, MoonshineMemoryModelConfig, MoonshineModelConfig, MoonshinePlatformStatus, MoonshineProcessUtteranceResult, MoonshineTranscriptEvent, MoonshineTranscriptionResult, MoonshineTranscribeParams } from '../types/interfaces';
type MoonshineListener = (event: MoonshineTranscriptEvent) => void;
export declare class MoonshineTranscriber {
    private readonly service;
    readonly transcriberId: string;
    constructor(service: MoonshineService, transcriberId: string);
    addAudio(samples: number[], sampleRate: number): Promise<{
        success: boolean;
    }>;
    addAudioToStream(streamId: string, samples: number[], sampleRate: number): Promise<{
        success: boolean;
    }>;
    addListener(listener: MoonshineListener): () => void;
    createStream(): Promise<string>;
    cancel(): Promise<MoonshineCancelTranscriptionResult>;
    release(): Promise<{
        released: boolean;
    }>;
    removeStream(_streamId: string): Promise<{
        success: boolean;
    }>;
    start(): Promise<{
        success: boolean;
    }>;
    startStream(streamId: string): Promise<{
        success: boolean;
    }>;
    stop(): Promise<{
        success: boolean;
    }>;
    stopStream(streamId: string): Promise<{
        success: boolean;
    }>;
    transcribe(params: MoonshineTranscribeParams): Promise<MoonshineTranscriptionResult>;
}
export declare class MoonshineIntentRecognizer {
    private readonly service;
    readonly intentRecognizerId: string;
    constructor(service: MoonshineService, intentRecognizerId: string);
    clearIntents(): Promise<{
        success: boolean;
    }>;
    getIntentCount(): Promise<number>;
    getIntentThreshold(): Promise<number>;
    processUtterance(utterance: string): Promise<MoonshineProcessUtteranceResult>;
    registerIntent(triggerPhrase: string): Promise<{
        success: boolean;
    }>;
    release(): Promise<{
        success: boolean;
    }>;
    setIntentThreshold(threshold: number): Promise<{
        success: boolean;
    }>;
    unregisterIntent(triggerPhrase: string): Promise<{
        success: boolean;
    }>;
}
export declare class MoonshineService {
    private defaultTranscriber;
    private readonly intentModelCache;
    private nextIntentRecognizerId;
    private readonly intentRecognizers;
    private readonly listeners;
    private readonly modelCache;
    private nextTranscriberId;
    private readonly offlineProgressTracker;
    private readonly transcribers;
    addAudio(samples: number[], sampleRate: number): Promise<{
        success: boolean;
    }>;
    addAudioForTranscriber(transcriberId: string, samples: number[], sampleRate: number): Promise<{
        success: boolean;
    }>;
    addAudioToStream(streamId: string, samples: number[], sampleRate: number): Promise<{
        success: boolean;
    }>;
    addAudioToStreamForTranscriber(transcriberId: string, streamId: string, samples: number[], sampleRate: number): Promise<{
        success: boolean;
    }>;
    addListener(listener: MoonshineListener): () => void;
    clearIntents(intentRecognizerId: string): Promise<{
        success: boolean;
    }>;
    createIntentRecognizer(config: MoonshineCreateIntentRecognizerConfig): Promise<MoonshineIntentRecognizer>;
    createStream(): Promise<string>;
    createStreamForTranscriber(transcriberId: string): Promise<string>;
    createTranscriberFromAssets(config: MoonshineAssetModelConfig): Promise<MoonshineTranscriber>;
    createTranscriberFromFiles(config: MoonshineModelConfig): Promise<MoonshineTranscriber>;
    createTranscriberFromMemory(config: MoonshineMemoryModelConfig): Promise<MoonshineTranscriber>;
    errorToString(code: number): Promise<string>;
    cancel(): Promise<MoonshineCancelTranscriptionResult>;
    cancelForTranscriber(transcriberId: string): Promise<MoonshineCancelTranscriptionResult>;
    getIntentCount(_intentRecognizerId: string): Promise<number>;
    getIntentThreshold(_intentRecognizerId: string): Promise<number>;
    getPlatformStatus(): MoonshinePlatformStatus;
    getVersion(): Promise<number>;
    isAvailable(): boolean;
    initialize(config: MoonshineModelConfig): Promise<MoonshineInitializeResult>;
    loadFromAssets(config: MoonshineAssetModelConfig): Promise<MoonshineInitializeResult>;
    loadFromFiles(config: MoonshineModelConfig): Promise<MoonshineInitializeResult>;
    loadFromMemory(config: MoonshineMemoryModelConfig): Promise<MoonshineInitializeResult>;
    release(): Promise<{
        released: boolean;
    }>;
    releaseTranscriber(transcriberId: string): Promise<{
        released: boolean;
    }>;
    releaseIntentRecognizer(_intentRecognizerId: string): Promise<{
        success: boolean;
    }>;
    removeAllListeners(): void;
    removeStream(streamId: string): Promise<{
        success: boolean;
    }>;
    removeStreamForTranscriber(transcriberId: string, streamId: string): Promise<{
        success: boolean;
    }>;
    processUtterance(_intentRecognizerId: string, _utterance: string): Promise<MoonshineProcessUtteranceResult>;
    registerIntent(_intentRecognizerId: string, _triggerPhrase: string): Promise<{
        success: boolean;
    }>;
    setIntentThreshold(_intentRecognizerId: string, _threshold: number): Promise<{
        success: boolean;
    }>;
    start(): Promise<{
        success: boolean;
    }>;
    startTranscriber(transcriberId: string): Promise<{
        success: boolean;
    }>;
    startStream(streamId: string): Promise<{
        success: boolean;
    }>;
    startStreamForTranscriber(transcriberId: string, streamId: string): Promise<{
        success: boolean;
    }>;
    stop(): Promise<{
        success: boolean;
    }>;
    stopTranscriber(transcriberId: string): Promise<{
        success: boolean;
    }>;
    stopStream(streamId: string): Promise<{
        success: boolean;
    }>;
    stopStreamForTranscriber(transcriberId: string, streamId: string): Promise<{
        success: boolean;
    }>;
    transcribe(params: MoonshineTranscribeParams): Promise<MoonshineTranscriptionResult>;
    transcribeForTranscriber(transcriberId: string, params: MoonshineTranscribeParams): Promise<MoonshineTranscriptionResult>;
    unregisterIntent(_intentRecognizerId: string, _triggerPhrase: string): Promise<{
        success: boolean;
    }>;
    private createTranscriberFromResult;
    private transcribePcmForTranscriber;
    private createWebTranscriber;
    private getOrCreateWebModel;
    private createWebTranscriberFromMemory;
    private emit;
    private getIntentRecognizerState;
    private ensureDefaultTranscriber;
    private getTranscriberState;
    private processUtteranceInternal;
    private registerIntentInternal;
    private replaceDefaultTranscriberFromResult;
    private beginOfflineTranscription;
    private clearOfflineTranscription;
    private throwIfOfflineTranscriptionCancelled;
    private transcribeViaTemporaryStream;
    private yieldToEventLoop;
    private emitOfflineProgressEvent;
    private transcribeWebOfflineWithWordTimestamps;
    private runWindowedWordTimestampPass;
    private getStreamState;
    private addAudioToStreamState;
    private scheduleStreamTranscription;
    private runQueuedStreamTranscription;
    private resetCurrentLine;
    private stopStreamInternal;
}
export {};
//# sourceMappingURL=MoonshineService.web.d.ts.map