use-stt/dist/index.d.ts

React hook for speech-to-text using multiple STT providers

import { FFmpeg } from '@ffmpeg/ffmpeg';

type STTProvider = 'whisper' | 'azure' | 'google';
interface TranscriptionSegment {
    text: string;
    start: number;
    end: number;
    confidence?: number;
}
interface TranscriptionResult {
    text: string;
    language?: string;
    confidence?: number;
    segments?: TranscriptionSegment[];
}
interface TranscriptionOptions {
    language?: string;
    prompt?: string;
}
type AudioMimeType = 'audio/webm' | 'audio/mp4' | 'audio/wav' | 'audio/ogg';
interface AudioMetadata {
    duration: number;
    sampleRate: number;
    channels: number;
    format: AudioMimeType;
    size: number;
}
interface FFmpegConfig {
    inputFormat?: string;
    inputSampleRate?: number;
    inputChannels?: number;
    outputFormat?: string;
    outputSampleRate?: number;
    outputChannels?: number;
    codec?: string;
    bitrate?: string;
    normalize?: boolean;
    normalizationLevel?: number;
    denoise?: boolean;
    trim?: {
        start?: number;
        duration?: number;
    };
    compressionLevel?: number;
    vad?: boolean;
    vadLevel?: number;
    filters?: string[];
}
interface STTOptions {
    provider: STTProvider;
    transcribe: (audioBlob: Blob) => Promise<{
        transcript: string;
        confidence?: number;
    }>;
    language?: string;
    model?: string;
    prompt?: string;
    onResult?: (result: STTResult) => void;
    onError?: (error: Error) => void;
    onStart?: () => void;
    onEnd?: () => void;
    disabled?: boolean;
}
interface STTResult {
    transcript: string;
    isFinal: boolean;
    confidence?: number;
}
interface STTErrorData {
    code: string;
    message: string;
    provider?: STTProvider;
}
interface STTState {
    isRecording: boolean;
    isProcessing: boolean;
    transcript: string;
    error: Error | null;
}
interface STTAdapter {
    transcribe(audioBlob: Blob, options?: TranscriptionOptions): Promise<TranscriptionResult>;
    start(): Promise<void>;
    stop(): Promise<void>;
    pause(): Promise<void>;
    resume(): Promise<void>;
    abort(): void;
}

interface UseSTTResult {
    transcript: string;
    isRecording: boolean;
    isProcessing: boolean;
    error: Error | null;
    isInitialized: boolean;
    isStopping: boolean;
    startRecording: () => Promise<void>;
    stopRecording: () => Promise<void>;
    pauseRecording: () => void;
    resumeRecording: () => void;
}
declare function useSTT(options: STTOptions): UseSTTResult;

interface AudioRecorderOptions {
    onDataAvailable?: (data: Blob) => void;
    onError?: (error: Error) => void;
    mimeType?: string;
}
declare class AudioRecorder {
    private mediaRecorder;
    private stream;
    private options;
    constructor(options: AudioRecorderOptions);
    private getSupportedMimeType;
    start(): Promise<void>;
    stop(): Promise<void>;
    pause(): void;
    resume(): void;
    private cleanup;
}

declare abstract class BaseAdapter {
    protected options: STTOptions;
    protected recorder: AudioRecorder | null;
    protected resultCallback?: (result: STTResult) => void;
    protected errorCallback?: (error: Error) => void;
    protected startCallback?: () => void;
    protected endCallback?: () => void;
    constructor(options: STTOptions);
    protected handleError(error: unknown): void;
    protected abstract processAudio(audioBlob: Blob): Promise<STTResult>;
    start(): Promise<void>;
    stop(): Promise<void>;
    pause(): void;
    resume(): void;
    abort(): Promise<void>;
    onResult(callback: (result: STTResult) => void): void;
    onError(callback: (error: Error) => void): void;
    onStart(callback: () => void): void;
    onEnd(callback: () => void): void;
}

interface WhisperAdapterOptions extends STTOptions {
    ffmpeg: FFmpeg;
    onResult?: (result: STTResult) => void;
    onError?: (error: Error) => void;
    onStart?: () => void;
    onEnd?: () => void;
}
declare class WhisperAdapter extends BaseAdapter {
    private ffmpeg;
    constructor(options: WhisperAdapterOptions);
    protected processAudio(audioBlob: Blob): Promise<STTResult>;
}

declare function convertAudioToWebM(ffmpeg: FFmpeg, file: File | Blob, config?: FFmpegConfig): Promise<Blob>;
declare function convertAudioToMono(ffmpeg: FFmpeg, file: File | Blob): Promise<Blob>;
declare function convertWithFFmpeg(ffmpeg: FFmpeg, file: File | Blob, config?: FFmpegConfig): Promise<Blob>;
declare function getAudioMetadata(ffmpeg: FFmpeg, file: File | Blob): Promise<AudioMetadata>;

export { type AudioMetadata, type AudioMimeType, type FFmpegConfig, type STTAdapter, type STTErrorData, type STTOptions, type STTProvider, type STTResult, type STTState, type TranscriptionOptions, type TranscriptionResult, type TranscriptionSegment, WhisperAdapter, convertAudioToMono, convertAudioToWebM, convertWithFFmpeg, getAudioMetadata, useSTT };