import * as ort from "onnxruntime-web";
import type { ModelConfig } from "./model-types.js";
import type { AsrTranscriber, AudioSamples, OrtTensor, TranscriptResult } from "./types.js";
type TokenMap = Record<string, number>;
type TokenMatrix = number[][];
type TensorMetadata = {
    name: string;
    type?: string;
    shape?: readonly (number | string | undefined)[];
};
interface WhisperDecodeOptions {
    language?: string;
    maxLength?: number;
}
interface WhisperBaseOptions {
    config: ModelConfig;
    vocab: TokenMap;
    addedTokens: TokenMap;
}
interface WhisperOrtOptions extends WhisperBaseOptions {
    session: ort.InferenceSession;
}
interface WhisperHfOptions extends WhisperBaseOptions {
    encoderSession: ort.InferenceSession;
    decoderSession: ort.InferenceSession;
}
declare class WhisperBaseModel implements AsrTranscriber {
    readonly config: ModelConfig;
    readonly tokens: TokenMap;
    readonly vocabById: Map<number, string>;
    readonly bosTokenId: number;
    readonly eosTokenId: number;
    readonly transcribeTokenId: number;
    readonly notimestampsTokenId: number;
    readonly transcribeInput: TokenMatrix;
    readonly detectLangInput: TokenMatrix;
    readonly byteDecoder: Map<string, number>;
    readonly sampleRate: number;
    readonly nMels: number;
    constructor({ config, vocab, addedTokens }: WhisperBaseOptions);
    _prepareFeatures(samples: AudioSamples, sampleRate: number): ort.Tensor;
    _decodeTokens(tokens: readonly number[]): string;
    _decoding(_inputFeatures: ort.Tensor, _tokens: TokenMatrix, _maxLength?: number): Promise<TokenMatrix>;
    _recognizeFeatures(inputFeatures: ort.Tensor, options?: WhisperDecodeOptions): Promise<TranscriptResult>;
    transcribeSamples(samples: AudioSamples, sampleRate?: number, options?: WhisperDecodeOptions): Promise<TranscriptResult>;
    transcribeWavBuffer(arrayBuffer: ArrayBuffer, options?: WhisperDecodeOptions): Promise<TranscriptResult>;
}
export declare class WhisperOrtModel extends WhisperBaseModel {
    readonly session: ort.InferenceSession;
    readonly inputMetadata: Map<string, TensorMetadata>;
    readonly outputName: string;
    constructor({ config, vocab, addedTokens, session }: WhisperOrtOptions);
    _paramTensor(name: string, value: number): ort.Tensor | null;
    _decoding(inputFeatures: ort.Tensor, tokens: TokenMatrix, maxLength?: number): Promise<TokenMatrix>;
}
export declare class WhisperHfModel extends WhisperBaseModel {
    readonly encoderSession: ort.InferenceSession;
    readonly decoderSession: ort.InferenceSession;
    readonly decoderInputMeta: Map<string, TensorMetadata>;
    readonly decoderOutputNames: readonly string[];
    readonly inputIdName: string;
    readonly encoderHiddenName: string;
    readonly useCacheBranchName: string | null;
    readonly pastInputNames: string[];
    constructor({ config, vocab, addedTokens, encoderSession, decoderSession }: WhisperHfOptions);
    _emptyStateTensor(meta: TensorMetadata): ort.Tensor;
    _createState(): Map<string, ort.Tensor>;
    _decoderInputTensor(tokens: TokenMatrix, useCache: boolean): ort.Tensor;
    _encode(inputFeatures: ort.Tensor): Promise<OrtTensor>;
    _decodeStep(tokens: TokenMatrix, state: Map<string, ort.Tensor>, encoderOut: OrtTensor): Promise<{
        logits: ort.Tensor;
        nextState: Map<string, ort.Tensor>;
    }>;
    _decoding(inputFeatures: ort.Tensor, tokens: TokenMatrix, maxLength?: number): Promise<TokenMatrix>;
}
export {};
//# sourceMappingURL=whisper.d.ts.map