import { type VaultLoadPlan, type VaultResolvedAsset } from './vault.js';
export declare const DREAMER_AUDIO_TIMEOUT_MS: number;
export type DreamerAudioGenerationMode = 'sound_effect' | 'music' | 'text_to_speech';
export type DreamerAudioVoiceSettings = {
    stability?: number;
    similarityBoost?: number;
    style?: number;
    speed?: number;
    speakerBoost?: boolean;
};
type DreamerAudioRequestBase = {
    additionalPrompt?: string;
    projectId?: string;
    sessionId?: string;
    title?: string;
    model?: string;
    outputFormat?: string;
};
export type DreamerSoundEffectRequest = DreamerAudioRequestBase & {
    audioMode: 'sound_effect';
    prompt: string;
    durationSeconds?: number;
    loop?: boolean;
    promptInfluence?: number;
};
export type DreamerMusicRequest = DreamerAudioRequestBase & {
    audioMode: 'music';
    prompt: string;
    durationSeconds?: number;
    forceInstrumental?: boolean;
};
export type DreamerTextToSpeechRequest = DreamerAudioRequestBase & {
    audioMode: 'text_to_speech';
    text: string;
    voiceId: string;
    languageCode?: string;
    seed?: number;
    voiceSettings?: DreamerAudioVoiceSettings;
    pronunciationDictionaryIds?: string[];
};
export type DreamerAudioGenerateRequest = DreamerSoundEffectRequest | DreamerMusicRequest | DreamerTextToSpeechRequest;
export type DreamerAudioArtifact = {
    url: string;
    contentType: string;
    sizeBytes: number;
    kind: 'audio';
};
type DreamerAudioJobBase = {
    jobId: string;
    units?: number;
    providerCostUsd?: number;
    billingEvidence?: 'measured_provider_credits' | 'estimated_accepted_duration';
    vaultAssetId?: string | null;
    vaultAutoPublish?: 'published' | 'disabled';
};
export type DreamerAudioPendingJob = DreamerAudioJobBase & {
    status: 'queued' | 'running';
};
export type DreamerAudioFailedJob = DreamerAudioJobBase & {
    status: 'failed';
    error?: string;
};
export type DreamerAudioSucceededJob = DreamerAudioJobBase & {
    status: 'succeeded';
    asset: DreamerAudioArtifact;
};
export type DreamerAudioJob = DreamerAudioPendingJob | DreamerAudioFailedJob | DreamerAudioSucceededJob;
export type DreamerAudioClientOptions = {
    /**
     * HELIX API origin, or a full base ending in `/api/v1/dreamer`.
     */
    apiBaseUrl: string;
    fetch?: typeof fetch;
    accessToken?: string | null | (() => string | null | Promise<string | null>);
    pollIntervalMs?: number;
    timeoutMs?: number;
};
export type DreamerAudioPollOptions = {
    pollIntervalMs?: number;
    timeoutMs?: number;
    onProgress?: (job: DreamerAudioJob) => void;
};
export type DreamerGeneratedVaultAudio = {
    job: DreamerAudioSucceededJob;
    resolved: VaultResolvedAsset<'audio'>;
    loadPlan: Extract<VaultLoadPlan, {
        loader: 'audio';
    }>;
};
export type DreamerAudioClient = {
    start(input: DreamerAudioGenerateRequest): Promise<{
        jobId: string;
        status: 'queued';
    }>;
    get(jobId: string): Promise<DreamerAudioJob>;
    generate(input: DreamerAudioGenerateRequest, options?: DreamerAudioPollOptions): Promise<DreamerAudioSucceededJob>;
    /**
     * Generate, require default-on Vault publication, then resolve the same
     * durable asset through the SDK's normal Vault consumption surface.
     */
    generateAndResolve(input: DreamerAudioGenerateRequest, options?: DreamerAudioPollOptions): Promise<DreamerGeneratedVaultAudio>;
};
export declare class DreamerAudioApiError extends Error {
    readonly status: number;
    readonly url: string;
    readonly responseBody: string;
    constructor(status: number, url: string, responseBody: string);
}
export declare class DreamerAudioJobFailedError extends Error {
    readonly job: DreamerAudioFailedJob;
    constructor(job: DreamerAudioFailedJob);
}
export declare class DreamerAudioJobTimeoutError extends Error {
    readonly jobId: string;
    readonly timeoutMs: number;
    constructor(jobId: string, timeoutMs: number);
}
export declare class DreamerAudioVaultUnavailableError extends Error {
    readonly job: DreamerAudioSucceededJob;
    constructor(job: DreamerAudioSucceededJob);
}
export declare class DreamerAudioCapabilityUnavailableError extends Error {
    constructor();
}
export declare function createDreamerAudioClient(options: DreamerAudioClientOptions): DreamerAudioClient;
export {};