import * as _ai_sdk_provider from '@ai-sdk/provider';
import { SpeechModelV4, ProviderV4 } from '@ai-sdk/provider';
import { FetchFunction, WORKFLOW_SERIALIZE, WORKFLOW_DESERIALIZE } from '@ai-sdk/provider-utils';
import { z } from 'zod/v4';

type HumeConfig = {
    provider: string;
    url: (options: {
        modelId: string;
        path: string;
    }) => string;
    headers?: () => Record<string, string | undefined>;
    fetch?: FetchFunction;
    generateId?: () => string;
};

interface HumeSpeechModelConfig extends HumeConfig {
    _internal?: {
        currentDate?: () => Date;
    };
}
declare class HumeSpeechModel implements SpeechModelV4 {
    readonly modelId: '';
    private readonly config;
    readonly specificationVersion = "v4";
    get provider(): string;
    static [WORKFLOW_SERIALIZE](model: HumeSpeechModel): {
        modelId: string;
        config: _ai_sdk_provider.JSONObject;
    };
    static [WORKFLOW_DESERIALIZE](options: {
        modelId: '';
        config: HumeSpeechModelConfig;
    }): HumeSpeechModel;
    constructor(modelId: '', config: HumeSpeechModelConfig);
    private getArgs;
    doGenerate(options: Parameters<SpeechModelV4['doGenerate']>[0]): Promise<Awaited<ReturnType<SpeechModelV4['doGenerate']>>>;
}

interface HumeProvider extends ProviderV4 {
    (settings?: {}): {
        speech: HumeSpeechModel;
    };
    /**
     * Creates a model for speech synthesis.
     */
    speech(): SpeechModelV4;
}
interface HumeProviderSettings {
    /**
     * API key for authenticating requests.
     */
    apiKey?: string;
    /**
     * Custom headers to include in the requests.
     */
    headers?: Record<string, string>;
    /**
     * Custom fetch implementation. You can use it as a middleware to intercept requests,
     * or to provide a custom fetch implementation for e.g. testing.
     */
    fetch?: FetchFunction;
}
/**
 * Create an Hume provider instance.
 */
declare function createHume(options?: HumeProviderSettings): HumeProvider;
/**
 * Default Hume provider instance.
 */
declare const hume: HumeProvider;

declare const humeSpeechModelOptionsSchema: z.ZodObject<{
    context: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
        generationId: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
        utterances: z.ZodArray<z.ZodObject<{
            text: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            speed: z.ZodOptional<z.ZodNumber>;
            trailingSilence: z.ZodOptional<z.ZodNumber>;
            voice: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
                id: z.ZodString;
                provider: z.ZodOptional<z.ZodEnum<{
                    HUME_AI: "HUME_AI";
                    CUSTOM_VOICE: "CUSTOM_VOICE";
                }>>;
            }, z.core.$strip>, z.ZodObject<{
                name: z.ZodString;
                provider: z.ZodOptional<z.ZodEnum<{
                    HUME_AI: "HUME_AI";
                    CUSTOM_VOICE: "CUSTOM_VOICE";
                }>>;
            }, z.core.$strip>]>>;
        }, z.core.$strip>>;
    }, z.core.$strip>]>>>;
}, z.core.$strip>;
type HumeSpeechModelOptions = z.infer<typeof humeSpeechModelOptionsSchema>;

declare const VERSION: string;

export { type HumeProvider, type HumeProviderSettings, type HumeSpeechModelOptions, VERSION, createHume, hume };