/** GPT-Realtime-Whisper session minting and server-side streaming client. */
import { EventEmitter } from "node:events";
import type { AuthInput } from "./auth.js";
import { type RealtimeTranscriptionModel } from "./config.js";
import { type ClientSecretRequestOptions, type MintedClientSecret } from "./client-secret.js";
import { type RealtimeServerEvent, type RealtimeSocketOptions } from "./socket.js";
export type TranscriptionDelay = "minimal" | "low" | "medium" | "high" | "xhigh";
export type TranscriptionInclude = "item.input_audio_transcription.logprobs" | (string & {});
export declare class TranscriptionConfigError extends Error {
    readonly name = "TranscriptionConfigError";
}
export interface RealtimePcmFormat {
    type: "audio/pcm";
    rate: 24_000;
}
export interface TranscriptionModelConfig {
    model: RealtimeTranscriptionModel;
    language?: string;
    delay?: TranscriptionDelay;
}
export interface TranscriptionAudioInput {
    format: RealtimePcmFormat;
    transcription: TranscriptionModelConfig;
    noise_reduction?: null | {
        type: "near_field" | "far_field" | (string & {});
    };
    turn_detection?: null;
    [key: string]: unknown;
}
export interface TranscriptionSessionConfig {
    type: "transcription";
    audio: {
        input: TranscriptionAudioInput;
        [key: string]: unknown;
    };
    include?: TranscriptionInclude[];
    [key: string]: unknown;
}
export interface TranscriptionSessionOverlay {
    type?: "transcription";
    audio?: {
        input?: {
            format?: RealtimePcmFormat;
            transcription?: Partial<TranscriptionModelConfig>;
            noise_reduction?: TranscriptionAudioInput["noise_reduction"];
            turn_detection?: null;
            [key: string]: unknown;
        };
        [key: string]: unknown;
    };
    include?: TranscriptionInclude[];
    [key: string]: unknown;
}
export interface BuildTranscriptionSessionOptions {
    model?: RealtimeTranscriptionModel;
    language?: string;
    delay?: TranscriptionDelay;
    include?: readonly TranscriptionInclude[];
    session?: TranscriptionSessionOverlay;
}
export declare function buildTranscriptionSession(options?: BuildTranscriptionSessionOptions): TranscriptionSessionConfig;
export interface TranscriptionSessionServiceOptions extends ClientSecretRequestOptions {
    defaultModel?: RealtimeTranscriptionModel;
    defaultLanguage?: string;
    defaultDelay?: TranscriptionDelay;
    defaultInclude?: readonly TranscriptionInclude[];
}
export interface MintTranscriptionOptions extends BuildTranscriptionSessionOptions {
    signal?: AbortSignal;
}
export interface MintedTranscriptionSecret extends MintedClientSecret<TranscriptionSessionConfig> {
    model: RealtimeTranscriptionModel;
}
export declare class TranscriptionSessionService {
    private readonly options;
    constructor(options?: TranscriptionSessionServiceOptions);
    buildSession(options?: BuildTranscriptionSessionOptions): TranscriptionSessionConfig;
    mint(options?: MintTranscriptionOptions): Promise<MintedTranscriptionSecret>;
}
export declare function mintTranscriptionClientSecret(options?: MintTranscriptionOptions, serviceOptions?: TranscriptionSessionServiceOptions): Promise<MintedTranscriptionSecret>;
export interface TranscriptionDelta {
    delta: string;
    itemId: string;
    contentIndex: number;
    logprobs?: unknown;
}
export interface TranscriptionCompleted {
    transcript: string;
    itemId: string;
    contentIndex: number;
    usage?: unknown;
}
export interface RealtimeTranscriptionClientOptions extends BuildTranscriptionSessionOptions, Omit<RealtimeSocketOptions, "query"> {
    auth?: AuthInput;
}
export declare interface RealtimeTranscriptionClient {
    on(event: "open", listener: () => void): this;
    on(event: "session", listener: (session: unknown) => void): this;
    on(event: "transcript.delta", listener: (event: TranscriptionDelta) => void): this;
    on(event: "transcript.completed", listener: (event: TranscriptionCompleted) => void): this;
    on(event: "speech.started" | "speech.stopped", listener: () => void): this;
    on(event: "buffer.committed", listener: (itemId?: string) => void): this;
    on(event: "server.error", listener: (error: unknown) => void): this;
    on(event: "client.error", listener: (error: Error) => void): this;
    on(event: "event", listener: (event: RealtimeServerEvent) => void): this;
    on(event: "close", listener: (code: number, reason: string) => void): this;
}
export declare class RealtimeTranscriptionClient extends EventEmitter {
    private readonly options;
    private readonly transport;
    private session;
    constructor(options?: RealtimeTranscriptionClientOptions);
    get model(): RealtimeTranscriptionModel;
    get isOpen(): boolean;
    connect(): Promise<void>;
    updateSession(options?: BuildTranscriptionSessionOptions): void;
    private sendSessionUpdate;
    private dispatch;
    appendAudio(pcm: Buffer | Uint8Array): void;
    commitAudio(): void;
    clearAudio(): void;
    sendRaw(payload: object): void;
    close(code?: number, reason?: string): void;
}
//# sourceMappingURL=transcription.d.ts.map