import * as ort from "onnxruntime-web";
import type { ModelConfig } from "./model-types.js";
import type { OrtTensor, TensorData, TensorMap, TokenFrame } from "./types.js";
type TensorShape = readonly number[];
type MetadataShape = readonly (number | string | undefined)[] | undefined;
type EncoderLayout = "BCT" | "BTV" | "BVT";
type TensorMetadata = {
    name: string;
    type?: string;
    shape?: MetadataShape;
};
interface EncoderModelOptions {
    config?: ModelConfig;
    sampleRate?: number;
}
interface DecoderTransducerOptions {
    decoderKind?: "tdt" | "rnnt";
    vocabSize?: number;
}
interface TransducerCandidate {
    token: number;
    duration: number;
}
interface DecoderPrediction {
    candidates: TransducerCandidate[];
    nextStates: Map<string, OrtTensor>;
}
interface EncodedAudio {
    encodedData: TensorData;
    encodedDims: TensorShape;
    encodedLayout: EncoderLayout;
    encodedLength: number;
}
interface DecoderResult {
    tokenIds: number[];
    tokenFrames: TokenFrame[];
    totalFrames: number;
}
interface TransducerDecoderLike {
    initialStates(): Map<string, OrtTensor>;
    predict(encoderFrameData: Float32Array, encoderFrameDims: TensorShape, token: number, states: Map<string, OrtTensor>): Promise<DecoderPrediction>;
}
interface TransducerGreedyDecoderOptions {
    maxSymbols?: number;
    blankTokenId?: number;
    defaultDuration?: number;
}
interface CtcGreedyDecoderOptions {
    blankTokenId?: number;
}
export declare class PreprocessorModel {
    readonly session: ort.InferenceSession;
    readonly inputSignalName: string;
    readonly lengthName: string;
    readonly lengthType: string;
    constructor(session: ort.InferenceSession);
    run(audioSamples: Float32Array): Promise<{
        signal: OrtTensor;
        length: OrtTensor;
    }>;
}
export declare class EncoderModel {
    readonly session: ort.InferenceSession;
    readonly options: EncoderModelOptions;
    readonly audioSignalName: string;
    readonly lengthName: string;
    readonly audioMetadata: TensorMetadata | undefined;
    readonly lengthMetadata: TensorMetadata | undefined;
    constructor(session: ort.InferenceSession, options?: EncoderModelOptions);
    prepareInputsFromWaveform(samples: Float32Array): {
        signal: OrtTensor;
        length: OrtTensor;
    };
    run(processedSignalTensor: OrtTensor, processedLengthTensor: OrtTensor): Promise<EncodedAudio>;
}
export declare class CtcAcousticModel extends EncoderModel {
    readonly vocabSize?: number;
    constructor(session: ort.InferenceSession, options?: EncoderModelOptions & {
        vocabSize?: number;
    });
    run(processedSignalTensor: OrtTensor, processedLengthTensor: OrtTensor): Promise<EncodedAudio>;
}
export declare class DecoderTransducerModel {
    readonly session: ort.InferenceSession;
    readonly decoderKind: "tdt" | "rnnt";
    readonly vocabSize?: number;
    readonly encoderOutputsName: string;
    readonly targetsName: string;
    readonly targetLengthName: string | null;
    readonly targetsType: string;
    readonly targetLengthType: string;
    readonly stateInputNames: string[];
    readonly stateInputMetadata: TensorMetadata[];
    readonly stateOutputNames: string[];
    constructor(session: ort.InferenceSession, options?: DecoderTransducerOptions);
    initialStates(): Map<string, OrtTensor>;
    resolveNextStates(outputs: TensorMap, currentStates: Map<string, OrtTensor>): Map<string, OrtTensor>;
    argmax(data: TensorData, start: number, end: number): number;
    rnntCandidates(mainOutputTensor: OrtTensor): TransducerCandidate[];
    tdtCandidates(mainOutputTensor: OrtTensor): TransducerCandidate[];
    predict(encoderFrameData: Float32Array, encoderFrameDims: TensorShape, token: number, states: Map<string, OrtTensor>): Promise<DecoderPrediction>;
}
export declare class TransducerGreedyDecoder {
    readonly model: TransducerDecoderLike;
    readonly maxSymbols: number;
    readonly blankTokenId: number;
    readonly defaultDuration: number;
    constructor(model: TransducerDecoderLike, options?: TransducerGreedyDecoderOptions);
    frameAt(encodedData: TensorData, encodedDims: TensorShape, encodedLayout: EncoderLayout, t: number): {
        data: Float32Array<ArrayBuffer>;
        dims: number[];
    };
    decode(encodedData: TensorData, encodedDims: TensorShape, encodedLayout: EncoderLayout, encodedLength: number): Promise<DecoderResult>;
}
export declare class CtcGreedyDecoder {
    readonly blankTokenId: number;
    constructor(options?: CtcGreedyDecoderOptions);
    argmaxAt(data: TensorData, start: number, size: number): number;
    decode(encodedData: TensorData, encodedDims: TensorShape, encodedLayout: EncoderLayout, encodedLength: number): Promise<DecoderResult>;
}
export {};
//# sourceMappingURL=models.d.ts.map