import type { ApiInterface } from './types/api';
export type {} from './web/wasmTypes';
declare const WebComposed: {
    new (...args: any[]): {
        _onnxSessions: Map<string, unknown>;
        _onnxNextId: number;
        createOnnxSession(config: {
            modelPath: string;
            numThreads?: number;
        }): Promise<import(".").OnnxSessionInfo>;
        runOnnxSession(sessionId: string, inputs: Record<string, import(".").OnnxTensorData>): Promise<import(".").OnnxInferenceResult>;
        releaseOnnxSession(sessionId: string): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        tts: import("./web/wasmTypes").OfflineTtsInstance | null;
        ttsSampleRate: number;
        ttsNumSpeakers: number;
        initTts(config: import(".").TtsModelConfig): Promise<import(".").TtsInitResult>;
        generateTts(config: import(".").TtsGenerateConfig): Promise<import(".").TtsGenerateResult>;
        stopTts(): Promise<{
            stopped: boolean;
            message?: string;
        }>;
        releaseTts(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        vad: import("./web/wasmTypes").VoiceActivityDetector | null;
        initVad(config: import(".").VadModelConfig): Promise<{
            success: boolean;
            error?: string;
        }>;
        acceptVadWaveform({ sampleRate, samples }: import("./types/api").WaveformInput): Promise<{
            success: boolean;
            isSpeechDetected: boolean;
            segments: any[];
            error?: string;
        }>;
        resetVad(): Promise<{
            success: boolean;
        }>;
        releaseVad(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        asrOnlineRecognizer: import("./web/wasmTypes").OnlineRecognizer | null;
        asrOnlineStream: import("./web/wasmTypes").OnlineStream | null;
        asrOfflineRecognizer: import("./web/wasmTypes").OfflineRecognizer | null;
        asrWorkerManager: import("./web/workers/WasmWorkerManager").WasmWorkerManager | null;
        initAsr(config: import(".").AsrModelConfig): Promise<import(".").AsrInitResult>;
        _initOnlineAsr(config: import(".").AsrModelConfig, opts: {
            debug: number;
            numThreads: number;
            sampleRate: number;
            modelDir: string;
            fetchBase: string;
            rawType: string;
        }): Promise<import(".").AsrInitResult>;
        _initOfflineAsr(config: import(".").AsrModelConfig, opts: {
            debug: number;
            numThreads: number;
            sampleRate: number;
            modelDir: string;
            fetchBase: string;
            rawType: string;
        }): Promise<import(".").AsrInitResult>;
        recognizeFromSamples({ sampleRate, samples, }: import("./types/api").WaveformInput): Promise<import(".").AsrRecognizeResult>;
        recognizeFromFile(filePath: string): Promise<import(".").AsrRecognizeResult>;
        _recognizeWorker(sampleRate: number, float32: Float32Array): Promise<import(".").AsrRecognizeResult>;
        _recognizeOffline(sampleRate: number, float32: Float32Array): import(".").AsrRecognizeResult;
        _recognizeOnline(sampleRate: number, float32: Float32Array): import(".").AsrRecognizeResult;
        releaseAsr(): Promise<{
            released: boolean;
        }>;
        createAsrOnlineStream(): Promise<{
            success: boolean;
        }>;
        acceptAsrOnlineWaveform({ sampleRate, samples, }: import("./types/api").WaveformInput): Promise<{
            success: boolean;
        }>;
        isAsrOnlineEndpoint(): Promise<{
            isEndpoint: boolean;
        }>;
        getAsrOnlineResult(): Promise<{
            text: string;
            tokens: string[];
            timestamps: number[];
        }>;
        finishAsrOnlineInput(): Promise<{
            success: boolean;
            error?: string;
        }>;
        resetAsrOnlineStream(): Promise<{
            success: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        kwsSpotter: import("./web/wasmTypes").KwsSpotter | null;
        kwsStream: import("./web/wasmTypes").KwsStream | null;
        initKws(config: import(".").KWSModelConfig): Promise<{
            success: boolean;
            error?: string;
        }>;
        acceptKwsWaveform({ sampleRate, samples }: import("./types/api").WaveformInput): Promise<{
            success: boolean;
            detected: boolean;
            keyword: string;
            error?: string;
        }>;
        resetKwsStream(): Promise<{
            success: boolean;
        }>;
        releaseKws(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        audioTagger: import("./web/wasmTypes").AudioTaggingInstance | null;
        initAudioTagging(config: import(".").AudioTaggingModelConfig): Promise<import(".").AudioTaggingInitResult>;
        processAndComputeAudioTagging({ filePath, }: import("./types/api").AudioTaggingFileInput): Promise<import(".").AudioTaggingResult>;
        processAndComputeAudioSamples({ sampleRate, samples: rawSamples, }: import("./types/api").AudioTaggingSamplesInput): Promise<import(".").AudioTaggingResult>;
        releaseAudioTagging(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        speakerExtractor: import("./web/wasmTypes").SpeakerEmbeddingExtractorInstance | null;
        speakerManager: import("./web/wasmTypes").SpeakerEmbeddingManagerInstance | null;
        speakerIdStream: number | null;
        speakerIdSamplesProcessed: number;
        initSpeakerId(config: import(".").SpeakerIdModelConfig): Promise<import(".").SpeakerIdInitResult>;
        processSpeakerIdSamples({ sampleRate, samples: rawSamples, }: import("./types/api").WaveformInput): Promise<import(".").SpeakerIdProcessResult>;
        computeSpeakerEmbedding(): Promise<import(".").SpeakerEmbeddingResult>;
        registerSpeaker({ name, embedding, }: import("./types/api").RegisterSpeakerInput): Promise<import(".").RegisterSpeakerResult>;
        removeSpeaker(name: string): Promise<import(".").RemoveSpeakerResult>;
        getSpeakers(): Promise<import(".").GetSpeakersResult>;
        identifySpeaker({ embedding, threshold, }: import("./types/api").IdentifySpeakerInput): Promise<import(".").IdentifySpeakerResult>;
        verifySpeaker({ name, embedding, threshold, }: import("./types/api").VerifySpeakerInput): Promise<import(".").VerifySpeakerResult>;
        processSpeakerIdFile(filePath: string): Promise<import(".").SpeakerIdFileProcessResult>;
        processSpeakerIdFileWindow({ filePath, startTimeMs, durationMs, }: {
            filePath: string;
            startTimeMs: number;
            durationMs: number;
        }): Promise<import(".").SpeakerIdFileWindowProcessResult>;
        resetSpeakerIdStream(): Promise<{
            success: boolean;
        }>;
        releaseSpeakerId(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        diarization: import("./web/wasmTypes").OfflineSpeakerDiarizationInstance | null;
        diarizationWorker: import("./web/workers/WasmWorkerManager").WasmWorkerManager | null;
        diarizationClustering: {
            numClusters: number;
            threshold: number;
        };
        initDiarization(config: any): Promise<{
            success: boolean;
            sampleRate: number;
            error?: string;
        }>;
        processDiarizationFile({ filePath, numClusters, threshold, }: import("./types/api").DiarizationFileInput): Promise<{
            success: boolean;
            segments: {
                start: number;
                end: number;
                speaker: number;
            }[];
            numSpeakers: number;
            durationMs: number;
            error?: string;
        }>;
        processDiarizationFileWindow({ filePath, startTimeMs, durationMs, numClusters, threshold, }: import("./types/api").DiarizationFileWindowInput): Promise<{
            success: boolean;
            segments: {
                start: number;
                end: number;
                speaker: number;
            }[];
            numSpeakers: number;
            durationMs: number;
            startTimeMs?: number;
            windowDurationMs?: number;
            sampleRate?: number;
            samples?: number;
            error?: string;
        }>;
        releaseDiarization(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        languageId: import("./web/wasmTypes").SpokenLanguageIdInstance | null;
        initLanguageId(config: any): Promise<{
            success: boolean;
            error?: string;
        }>;
        detectLanguage({ sampleRate, samples: rawSamples, }: import("./types/api").WaveformInput): Promise<{
            success: boolean;
            language: string;
            durationMs: number;
            error?: string;
        }>;
        detectLanguageFromFile(filePath: string): Promise<{
            success: boolean;
            language: string;
            durationMs: number;
            error?: string;
        }>;
        releaseLanguageId(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        punctuation: import("./web/wasmTypes").OnlinePunctuationInstance | null;
        initPunctuation(config: any): Promise<{
            success: boolean;
            error?: string;
        }>;
        addPunctuation(text: string): Promise<{
            success: boolean;
            text: string;
            durationMs: number;
            error?: string;
        }>;
        releasePunctuation(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        denoiser: import("./web/wasmTypes").OfflineSpeechDenoiserInstance | null;
        denoiserWorker: import("./web/workers/WasmWorkerManager").WasmWorkerManager | null;
        initDenoiser(config: any): Promise<{
            success: boolean;
            sampleRate: number;
            error?: string;
        }>;
        denoiseFile(filePath: string): Promise<{
            success: boolean;
            outputPath: string;
            durationMs: number;
            error?: string;
        }>;
        releaseDenoiser(): Promise<{
            released: boolean;
        }>;
    };
} & {
    new (...args: any[]): {
        testOnnxIntegration(): Promise<import(".").TestOnnxIntegrationResult>;
        validateLibraryLoaded(): Promise<import(".").ValidateResult>;
        getArchitectureInfo(): Promise<import("./types/api").ArchitectureInfo>;
        getSystemInfo(): Promise<import("./types/api").SystemInfo>;
        extractTarBz2(_input: import("./types/api").ExtractTarBz2Input): Promise<{
            success: boolean;
            message: string;
            extractedFiles: string[];
        }>;
    };
} & {
    new (): {};
};
export declare class WebSherpaOnnxImpl extends WebComposed implements ApiInterface {
}
//# sourceMappingURL=WebSherpaOnnxImpl.d.ts.map