import { LanguageModel } from 'ai';
import { Book, RebookPlugin, TextBlock } from '../core/types';
import { TTSCompactSpeakerTier } from './tts/speaker-schemas';
export { createBrowserTTSAudioPlayer } from './tts/audio-player';
type FetchLike = typeof fetch;
export interface TTSVoice {
    id: string;
    name: string;
    locale?: string;
    gender?: string;
    provider: string;
    capabilities?: TTSProviderCapabilities;
}
export interface TTSProviderCapabilities {
    tts?: boolean;
    tts_streaming?: boolean;
    asr?: boolean;
    asr_streaming?: boolean;
    voice_design?: boolean;
    voice_clone?: boolean;
    sound_effects?: boolean;
    isolation?: boolean;
}
export type TTSJsonPrimitive = string | number | boolean | null;
export type TTSJsonValue = TTSJsonPrimitive | TTSJsonObject | TTSJsonValue[];
export interface TTSJsonObject {
    [key: string]: TTSJsonValue;
}
export interface TTSProviderInfo {
    id: string;
    name: string;
    capabilities?: TTSProviderCapabilities;
}
export type TTSSpeakerRole = 'narrator' | 'character' | 'other';
export type TTSSpeakerGender = 'male' | 'female' | 'unknown';
export type TTSSpeakerTier = TTSCompactSpeakerTier;
export type TTSMixLayer = 'foreground' | 'midground' | 'background';
export interface TTSSpeakerVoiceProfile {
    speakerId?: number;
    voice?: string;
    speaker?: string;
    role?: TTSSpeakerRole;
    gender?: TTSSpeakerGender;
    tier?: TTSSpeakerTier;
    speakerHint?: string;
    speed?: number;
    pitch?: string;
    volume?: string;
    emotion?: string;
    voicePrompt?: string;
    stylePrompt?: string;
    mixLayer?: TTSMixLayer;
    volumeDb?: number;
    pan?: number;
}
export type TTSVoiceProfileEntry = string | TTSSpeakerVoiceProfile;
export type TTSVoiceProfileSlot = TTSVoiceProfileEntry | readonly TTSVoiceProfileEntry[];
export interface TTSVoiceProfile {
    narrator?: TTSVoiceProfileSlot;
    male?: TTSVoiceProfileSlot;
    female?: TTSVoiceProfileSlot;
    unknown?: TTSVoiceProfileSlot;
    other?: TTSVoiceProfileSlot;
    speakers?: Record<string, TTSVoiceProfileSlot>;
}
export interface TTSSpeakerVoiceAssignment {
    id?: number;
    speaker: string;
    role?: TTSSpeakerRole;
    gender?: TTSSpeakerGender;
    tier?: TTSSpeakerTier;
    voice?: string;
    speakerHint?: string;
    voicePrompt?: string;
    stylePrompt?: string;
}
export interface TTSSpeakerAnalysisBlock {
    blockId: string;
    blockType: TextBlock['type'];
    text: string;
}
export interface TTSSpeakerAnalysisSegment {
    blockId: string;
    startOffset: number;
    endOffset: number;
    speakerId?: number;
    speakerIds?: readonly number[];
    text?: string;
    speaker?: string;
    role?: TTSSpeakerRole;
    gender?: TTSSpeakerGender;
    tier?: TTSSpeakerTier;
    confidence?: number;
    voice?: string;
    speed?: number;
    pitch?: string;
    volume?: string;
    emotion?: string;
    voicePrompt?: string;
    stylePrompt?: string;
    mixLayer?: TTSMixLayer;
    volumeDb?: number;
    pan?: number;
}
export interface TTSSpeakerAnalysisRequest {
    sectionIndex: number;
    blocks: readonly TTSSpeakerAnalysisBlock[];
    knownSpeakers?: readonly TTSSpeakerVoiceAssignment[];
}
export interface TTSSpeakerAnalysis {
    segments: readonly TTSSpeakerAnalysisSegment[];
}
export interface TTSSpeakerAnalysisLogEvent {
    phase: 'scene' | 'plan' | 'initial' | 'repair';
    sectionIndex: number;
    request: unknown;
    response: unknown;
    durationMs: number;
    error?: string;
}
export type TTSSpeakerAnalysisPhase = 'scene' | 'plan' | 'initial' | 'repair';
export type TTSSpeakerAnalyzer = (request: TTSSpeakerAnalysisRequest) => Promise<TTSSpeakerAnalysis> | TTSSpeakerAnalysis;
export interface TTSSpeakerAnalysisOptions {
    model?: LanguageModel;
    prompt?: string;
    timeoutMs?: number;
    onLog?: (event: TTSSpeakerAnalysisLogEvent) => void | Promise<void>;
}
export interface TTSSegment {
    id: string;
    sectionIndex: number;
    blockId: string;
    blockType?: TextBlock['type'];
    startOffset: number;
    endOffset: number;
    ranges?: readonly TTSSegmentRange[];
    provider?: string;
    soundEffectPrompt?: string;
    soundEffectDurationSeconds?: number;
    speakerId?: number;
    speakerIds?: readonly number[];
    speaker: string;
    speakerRole?: TTSSpeakerRole;
    speakerGender?: TTSSpeakerGender;
    speakerTier?: TTSSpeakerTier;
    speakerConfidence?: number;
    text: string;
    voice?: string;
    mixLayer?: TTSMixLayer;
    volumeDb?: number;
    pan?: number;
    speed?: number;
    pitch?: string;
    volume?: string;
    emotion?: string;
    voicePrompt?: string;
    stylePrompt?: string;
    batchable?: boolean;
}
export interface TTSSegmentRange {
    blockId: string;
    blockType?: TextBlock['type'];
    startOffset: number;
    endOffset: number;
}
export interface TTSSectionOptions {
    provider?: string;
    soundEffectProvider?: string;
    voice?: string;
    speaker?: string;
    multiSpeaker?: boolean;
    voiceProfile?: TTSVoiceProfile;
    model?: LanguageModel;
    speakerAnalysis?: TTSSpeakerAnalysisOptions;
    speakerAnalyzer?: TTSSpeakerAnalyzer;
    maxSegmentChars?: number;
    includeFootnotes?: boolean;
    includeAnnotationRefs?: boolean;
}
export interface TTSSynthesizeOptions {
    provider?: string;
    voice?: string;
    lang?: string;
    outputFormat?: string;
    speed?: number;
    pitch?: string;
    volume?: string;
    stylePrompt?: string;
    extraParams?: TTSJsonObject;
}
export interface TTSSynthesizeResult {
    segmentId: string;
    audioUrl: string;
    fileName: string;
    mimeType: string;
    durationMs: number;
    cacheHit: boolean;
}
export interface TTSPrefetchOptions {
    concurrency?: number;
    pollIntervalMs?: number;
}
export type TTSSynthesisStatus = 'queued' | 'running' | 'done' | 'failed' | 'partial';
export interface TTSSynthesisState {
    id: string;
    status: TTSSynthesisStatus;
    provider: string;
    total: number;
    completed: number;
    failed: number;
    createdAt: string;
    updatedAt: string;
    error?: string;
    results: TTSSynthesizeResult[];
    failures?: TTSSynthesisFailure[];
}
export interface TTSSynthesisFailure {
    index: number;
    segmentId: string;
    speaker?: string;
    voice?: string;
    textPreview: string;
    error: string;
}
export interface TTSPrefetchedSection {
    readonly segments: TTSSegment[];
    readonly id: string;
    readonly total: number;
    refresh(): Promise<TTSSynthesisState>;
    getResult(segmentId: string): TTSSynthesizeResult | undefined;
    waitForSegment(segmentId: string, options?: {
        pollIntervalMs?: number;
        signal?: AbortSignal;
    }): Promise<TTSSynthesizeResult>;
}
export interface TTSAudioPlaybackEvent {
    segment: TTSSegment;
    index: number;
    total: number;
    result?: TTSSynthesizeResult;
}
export interface TTSAudioPlaybackErrorEvent extends TTSAudioPlaybackEvent {
    error: unknown;
}
export interface TTSAudioPlaybackOptions {
    signal?: AbortSignal;
    pollIntervalMs?: number;
    preloadAhead?: number;
    onSegmentQueued?: (event: TTSAudioPlaybackEvent) => void;
    onSegmentStart?: (event: TTSAudioPlaybackEvent) => void;
    onSegmentEnd?: (event: TTSAudioPlaybackEvent) => void;
    onSegmentError?: (event: TTSAudioPlaybackErrorEvent) => void;
}
export interface TTSAudioPlayer {
    playPrefetchedSection(prefetch: TTSPrefetchedSection, options?: TTSAudioPlaybackOptions): Promise<void>;
    stop(): void;
    destroy?(): void | Promise<void>;
}
export interface BrowserTTSAudioPlayerOptions {
    fetch?: FetchLike;
    audioContext?: AudioContext;
    preloadAhead?: number;
}
export interface TTSController {
    listProviders(): Promise<TTSProviderInfo[]>;
    listVoices(provider?: string): Promise<TTSVoice[]>;
    prepareSection(sectionIndex: number, options?: TTSSectionOptions): Promise<TTSSegment[]>;
    synthesizeSegment(segment: TTSSegment, options?: TTSSynthesizeOptions): Promise<TTSSynthesizeResult>;
    synthesizeSegments(segments: readonly TTSSegment[], options?: TTSSynthesizeOptions & TTSPrefetchOptions): Promise<TTSPrefetchedSection>;
    prefetchSection(sectionIndex: number, options?: TTSSectionOptions & TTSSynthesizeOptions & TTSPrefetchOptions): Promise<TTSPrefetchedSection>;
    playPrefetchedSection(prefetch: TTSPrefetchedSection, options?: TTSAudioPlaybackOptions): Promise<void>;
    stopPlayback(): void;
    readonly player?: TTSAudioPlayer;
}
export type TTSBook = Book & {
    readonly tts: TTSController;
};
export interface TTSOptions {
    endpoint?: string;
    provider?: string;
    soundEffectProvider?: string;
    voice?: string;
    lang?: string;
    outputFormat?: string;
    speed?: number;
    pitch?: string;
    volume?: string;
    speaker?: string;
    multiSpeaker?: boolean;
    voiceProfile?: TTSVoiceProfile;
    model?: LanguageModel;
    speakerAnalysis?: TTSSpeakerAnalysisOptions;
    speakerAnalyzer?: TTSSpeakerAnalyzer;
    maxSegmentChars?: number;
    includeFootnotes?: boolean;
    includeAnnotationRefs?: boolean;
    player?: TTSAudioPlayer;
    fetch?: FetchLike;
}
export declare function withTTS(options?: TTSOptions): RebookPlugin;
//# sourceMappingURL=tts.d.ts.map