import * as zod from 'zod';
import { z } from 'zod';
import { ChatModelV1, ChatModelSchemaType, UrlType, HeadersType, ParamsType, EmbeddingModelSchemaType, EmbeddingModelV1, ProviderV1 } from '@adaline/provider';
import { MessageType, ConfigType, ToolType, ChatResponseType, PartialChatResponseType, ChatModelPriceType, EmbeddingRequestsType, EmbeddingResponseType } from '@adaline/types';

declare const ChatModelBaseConfigSchema: (maxOutputTokens: number, maxSequences: number) => z.ZodObject<{
    temperature: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    maxTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    stop: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
    topP: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    topK: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    toolChoice: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
}, "strip", z.ZodTypeAny, {
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    stop?: string[] | undefined;
    topP?: number | undefined;
    topK?: number | undefined;
    toolChoice?: string | null | undefined;
}, {
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    stop?: string[] | undefined;
    topP?: number | undefined;
    topK?: number | undefined;
    toolChoice?: string | null | undefined;
}>;
declare const ChatModelBaseConfigDef: (maxOutputTokens: number, maxSequences: number) => {
    readonly temperature: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly maxTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly stop: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    readonly topP: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly topK: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    readonly toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};

declare const temperature: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const maxTokens: (maxOutputTokens: number) => {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const stop: (maxSequences: number) => {
    def: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
};
declare const topP: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const topK: {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
};
declare const toolChoice: {
    def: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
};

declare const ChatModelReasoningConfigDef: (maxOutputTokens: number, maxSequences: number, minReasoningToken: number, maxReasoningToken: number) => {
    reasoningEnabled: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    maxReasoningTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    temperature: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    maxTokens: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    stop: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    topP: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    topK: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    toolChoice: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
};
declare const ChatModelReasoningConfigSchema: (maxOutputTokens: number, maxSequences: number, minReasoningToken: number, maxReasoningToken: number) => zod.ZodObject<zod.objectUtil.extendShape<{
    temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
    topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    topK: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
    toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
}, {
    reasoningEnabled: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
    maxReasoningTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
}>, "strip", zod.ZodTypeAny, {
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    stop?: string[] | undefined;
    topP?: number | undefined;
    topK?: number | undefined;
    toolChoice?: string | null | undefined;
    reasoningEnabled?: boolean | null | undefined;
    maxReasoningTokens?: number | undefined;
}, {
    temperature?: number | undefined;
    maxTokens?: number | undefined;
    stop?: string[] | undefined;
    topP?: number | undefined;
    topK?: number | undefined;
    toolChoice?: string | null | undefined;
    reasoningEnabled?: boolean | null | undefined;
    maxReasoningTokens?: number | undefined;
}>;

declare const AnthropicChatModelConfigs: {
    readonly base: (maxOutputTokens: number, maxSequences: number) => {
        def: {
            readonly temperature: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly maxTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly stop: {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            };
            readonly topP: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly topK: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            readonly toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<{
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
            topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            topK: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, "strip", zod.ZodTypeAny, {
            temperature?: number | undefined;
            maxTokens?: number | undefined;
            stop?: string[] | undefined;
            topP?: number | undefined;
            topK?: number | undefined;
            toolChoice?: string | null | undefined;
        }, {
            temperature?: number | undefined;
            maxTokens?: number | undefined;
            stop?: string[] | undefined;
            topP?: number | undefined;
            topK?: number | undefined;
            toolChoice?: string | null | undefined;
        }>;
    };
    readonly extendedThinking: (maxOutputTokens: number, maxSequences: number, minReasoningToken: number, maxReasoningTokens: number) => {
        def: {
            reasoningEnabled: {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            };
            maxReasoningTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            temperature: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            maxTokens: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            stop: {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            };
            topP: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            topK: {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            };
            toolChoice: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
        };
        schema: zod.ZodObject<zod.objectUtil.extendShape<{
            temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            maxTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            stop: zod.ZodOptional<zod.ZodDefault<zod.ZodArray<zod.ZodString, "many">>>;
            topP: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            topK: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
            toolChoice: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
        }, {
            reasoningEnabled: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
            maxReasoningTokens: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
        }>, "strip", zod.ZodTypeAny, {
            temperature?: number | undefined;
            maxTokens?: number | undefined;
            stop?: string[] | undefined;
            topP?: number | undefined;
            topK?: number | undefined;
            toolChoice?: string | null | undefined;
            reasoningEnabled?: boolean | null | undefined;
            maxReasoningTokens?: number | undefined;
        }, {
            temperature?: number | undefined;
            maxTokens?: number | undefined;
            stop?: string[] | undefined;
            topP?: number | undefined;
            topK?: number | undefined;
            toolChoice?: string | null | undefined;
            reasoningEnabled?: boolean | null | undefined;
            maxReasoningTokens?: number | undefined;
        }>;
    };
};
declare const AnthropicEmbeddingModelConfigs: {
    readonly base: () => {
        def: {
            encodingFormat: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            inputType: {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            };
            truncation: {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            };
        };
        schema: zod.ZodObject<{
            encodingFormat: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
            inputType: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
            truncation: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
        }, "strip", zod.ZodTypeAny, {
            truncation?: boolean | null | undefined;
            encodingFormat?: string | null | undefined;
            inputType?: string | null | undefined;
        }, {
            truncation?: boolean | null | undefined;
            encodingFormat?: string | null | undefined;
            inputType?: string | null | undefined;
        }>;
    };
};

declare const EmbeddingModelBaseConfigSchema: () => z.ZodObject<{
    encodingFormat: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
    inputType: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
    truncation: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodBoolean>>>;
}, "strip", z.ZodTypeAny, {
    truncation?: boolean | null | undefined;
    encodingFormat?: string | null | undefined;
    inputType?: string | null | undefined;
}, {
    truncation?: boolean | null | undefined;
    encodingFormat?: string | null | undefined;
    inputType?: string | null | undefined;
}>;
declare const EmbeddingModelBaseConfigDef: () => {
    encodingFormat: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    inputType: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    truncation: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
};

declare const encodingFormat: {
    def: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
};
declare const inputType: {
    def: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodEnum<[string, ...string[]]>>>>;
};
declare const truncation: {
    def: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    schema: zod.ZodOptional<zod.ZodDefault<zod.ZodNullable<zod.ZodBoolean>>>;
};

declare const BaseChatModelOptions: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type BaseChatModelOptionsType = z.infer<typeof BaseChatModelOptions>;
declare class BaseChatModel implements ChatModelV1<ChatModelSchemaType> {
    readonly version: "v1";
    readonly modelName: string;
    modelSchema: ChatModelSchemaType;
    private readonly apiKey;
    private readonly baseUrl;
    private readonly completeChatUrl;
    private readonly streamChatUrl;
    constructor(modelSchema: ChatModelSchemaType, options: BaseChatModelOptionsType);
    getDefaultBaseUrl(): UrlType;
    getDefaultHeaders(): HeadersType;
    getDefaultParams(): ParamsType;
    getRetryDelay(responseHeaders: HeadersType): {
        shouldRetry: boolean;
        delayMs: number;
    };
    getTokenCount(messages: MessageType[]): number;
    transformModelRequest(request: any): {
        modelName: string | undefined;
        config: ConfigType;
        messages: MessageType[];
        tools: ToolType[] | undefined;
    };
    transformConfig(config: ConfigType, messages?: MessageType[], tools?: ToolType[]): ParamsType;
    transformMessages(messages: MessageType[]): ParamsType;
    transformTools(tools: ToolType[]): ParamsType;
    getCompleteChatUrl(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<UrlType>;
    getCompleteChatHeaders(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<HeadersType>;
    getCompleteChatData(config: ConfigType, messages: MessageType[], tools?: ToolType[]): Promise<ParamsType>;
    transformCompleteChatResponse(response: any): ChatResponseType;
    getStreamChatUrl(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<UrlType>;
    getStreamChatHeaders(config?: ConfigType, messages?: MessageType[], tools?: ToolType[]): Promise<HeadersType>;
    getStreamChatData(config: ConfigType, messages: MessageType[], tools?: ToolType[]): Promise<ParamsType>;
    transformStreamChatResponseChunk(chunk: string, buffer: string): AsyncGenerator<{
        partialResponse: PartialChatResponseType;
        buffer: string;
    }>;
    transformProxyStreamChatResponseChunk(chunk: string, buffer: string, data?: any, headers?: Record<string, string>, query?: Record<string, string>): AsyncGenerator<{
        partialResponse: PartialChatResponseType;
        buffer: string;
    }>;
    getProxyStreamChatUrl(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<UrlType>;
    getProxyCompleteChatUrl(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<UrlType>;
    getProxyCompleteChatHeaders(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<HeadersType>;
    getProxyStreamChatHeaders(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<HeadersType>;
    getModelPricing(): ChatModelPriceType;
}

declare const Claude4Opus20250514Literal = "claude-4-opus-20250514";
declare const Claude4Opus20250514Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response" | "reasoning", ...("text" | "image" | "tool-call" | "tool-response" | "reasoning")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude4Opus20250514Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude4Opus20250514OptionsType = z.infer<typeof Claude4Opus20250514Options>;
declare class Claude4Opus20250514 extends BaseChatModel {
    constructor(options: Claude4Opus20250514OptionsType);
}

declare const Claude4Sonnet20250514Literal = "claude-4-sonnet-20250514";
declare const Claude4Sonnet20250514Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response" | "reasoning", ...("text" | "image" | "tool-call" | "tool-response" | "reasoning")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude4Sonnet20250514Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude4Sonnet20250514OptionsType = z.infer<typeof Claude4Sonnet20250514Options>;
declare class Claude4Sonnet20250514 extends BaseChatModel {
    constructor(options: Claude4Sonnet20250514OptionsType);
}

declare const Claude3_5Sonnet20240620Literal = "claude-3-5-sonnet-20240620";
declare const Claude3_5Sonnet20240620Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3_5Sonnet20240620Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3_5Sonnet20240620OptionsType = z.infer<typeof Claude3_5Sonnet20240620Options>;
declare class Claude3_5Sonnet20240620 extends BaseChatModel {
    constructor(options: Claude3_5Sonnet20240620OptionsType);
}

declare const Claude3_5Sonnet20241022Literal = "claude-3-5-sonnet-20241022";
declare const Claude3_5Sonnet20241022Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3_5Sonnet20241022Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3_5Sonnet20241022OptionsType = z.infer<typeof Claude3_5Sonnet20241022Options>;
declare class Claude3_5Sonnet20241022 extends BaseChatModel {
    constructor(options: Claude3_5Sonnet20241022OptionsType);
}

declare const Claude3_7Sonnet20250219Literal = "claude-3-7-sonnet-20250219";
declare const Claude3_7Sonnet20250219Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response" | "reasoning", ...("text" | "image" | "tool-call" | "tool-response" | "reasoning")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3_7Sonnet20250219Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3_7Sonnet20250219OptionsType = z.infer<typeof Claude3_7Sonnet20250219Options>;
declare class Claude3_7Sonnet20250219 extends BaseChatModel {
    constructor(options: Claude3_7Sonnet20250219OptionsType);
    getDefaultHeaders(): HeadersType;
}

declare const Claude3Haiku20240307Literal = "claude-3-haiku-20240307";
declare const Claude3Haiku20240307Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3Haiku20240307Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3Haiku20240307OptionsType = z.infer<typeof Claude3Haiku20240307Options>;
declare class Claude3Haiku20240307 extends BaseChatModel {
    constructor(options: Claude3Haiku20240307OptionsType);
}

declare const Claude3_5Haiku20241022Literal = "claude-3-5-haiku-20241022";
declare const Claude3_5Haiku20241022Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3_5Haiku20241022Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3_5Haiku20241022OptionsType = z.infer<typeof Claude3_5Haiku20241022Options>;
declare class Claude3_5Haiku20241022 extends BaseChatModel {
    constructor(options: Claude3_5Haiku20241022OptionsType);
}

declare const Claude3Opus20240229Literal = "claude-3-opus-20240229";
declare const Claude3Opus20240229Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3Opus20240229Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3Opus20240229OptionsType = z.infer<typeof Claude3Opus20240229Options>;
declare class Claude3Opus20240229 extends BaseChatModel {
    constructor(options: Claude3Opus20240229OptionsType);
}

declare const Claude3Sonnet20240229Literal = "claude-3-sonnet-20240229";
declare const Claude3Sonnet20240229Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const Claude3Sonnet20240229Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    completeChatUrl: z.ZodOptional<z.ZodString>;
    streamChatUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    completeChatUrl?: string | undefined;
    streamChatUrl?: string | undefined;
}>;
type Claude3Sonnet20240229OptionsType = z.infer<typeof Claude3Sonnet20240229Options>;
declare class Claude3Sonnet20240229 extends BaseChatModel {
    constructor(options: Claude3Sonnet20240229OptionsType);
}

declare const AnthropicChatModelRoles: z.ZodEnum<["system", "user", "assistant", "tool"]>;
declare const AnthropicChatModelRolesMap: {
    readonly system: "system";
    readonly user: "user";
    readonly assistant: "assistant";
    readonly tool: "user";
};

declare const AnthropicChatModelModalities: ChatModelSchemaType["modalities"];
declare const AnthropicChatModelModalitiesEnum: z.ZodEnum<["text", "image", "tool-call", "tool-response"]>;
declare const AnthropicThinkingChatModelModalities: ChatModelSchemaType["modalities"];
declare const AnthropicThinkingChatModelModalitiesEnum: z.ZodEnum<["text", "image", "tool-call", "tool-response", "reasoning"]>;

declare const AnthropicCompleteChatResponse: z.ZodObject<{
    content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"text">;
        text: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool_use">;
        id: z.ZodString;
        name: z.ZodString;
        input: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        type: "tool_use";
        name: string;
        id: string;
        input: Record<string, any>;
    }, {
        type: "tool_use";
        name: string;
        id: string;
        input: Record<string, any>;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"thinking">;
        thinking: z.ZodString;
        signature: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "thinking";
        thinking: string;
        signature: string;
    }, {
        type: "thinking";
        thinking: string;
        signature: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"redacted_thinking">;
        data: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "redacted_thinking";
        data: string;
    }, {
        type: "redacted_thinking";
        data: string;
    }>]>, "many">;
    id: z.ZodString;
    model: z.ZodString;
    role: z.ZodString;
    stop_reason: z.ZodString;
    stop_sequence: z.ZodNull;
    type: z.ZodLiteral<"message">;
    usage: z.ZodObject<{
        input_tokens: z.ZodNumber;
        output_tokens: z.ZodNumber;
        cache_creation_input_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        cache_read_input_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, "strip", z.ZodTypeAny, {
        input_tokens: number;
        output_tokens: number;
        cache_creation_input_tokens?: number | null | undefined;
        cache_read_input_tokens?: number | null | undefined;
    }, {
        input_tokens: number;
        output_tokens: number;
        cache_creation_input_tokens?: number | null | undefined;
        cache_read_input_tokens?: number | null | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    type: "message";
    role: string;
    content: ({
        type: "text";
        text: string;
    } | {
        type: "tool_use";
        name: string;
        id: string;
        input: Record<string, any>;
    } | {
        type: "thinking";
        thinking: string;
        signature: string;
    } | {
        type: "redacted_thinking";
        data: string;
    })[];
    id: string;
    model: string;
    stop_reason: string;
    stop_sequence: null;
    usage: {
        input_tokens: number;
        output_tokens: number;
        cache_creation_input_tokens?: number | null | undefined;
        cache_read_input_tokens?: number | null | undefined;
    };
}, {
    type: "message";
    role: string;
    content: ({
        type: "text";
        text: string;
    } | {
        type: "tool_use";
        name: string;
        id: string;
        input: Record<string, any>;
    } | {
        type: "thinking";
        thinking: string;
        signature: string;
    } | {
        type: "redacted_thinking";
        data: string;
    })[];
    id: string;
    model: string;
    stop_reason: string;
    stop_sequence: null;
    usage: {
        input_tokens: number;
        output_tokens: number;
        cache_creation_input_tokens?: number | null | undefined;
        cache_read_input_tokens?: number | null | undefined;
    };
}>;
type AnthropicCompleteChatResponseType = z.infer<typeof AnthropicCompleteChatResponse>;
declare const AnthropicStreamChatMessageStartResponse: z.ZodObject<{
    type: z.ZodLiteral<"message_start">;
    message: z.ZodObject<{
        id: z.ZodString;
        type: z.ZodLiteral<"message">;
        role: z.ZodString;
        model: z.ZodString;
        stop_reason: z.ZodNullable<z.ZodString>;
        stop_sequence: z.ZodNullable<z.ZodString>;
        content: z.ZodArray<z.ZodAny, "many">;
        usage: z.ZodObject<{
            input_tokens: z.ZodNumber;
            output_tokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            input_tokens: number;
            output_tokens: number;
        }, {
            input_tokens: number;
            output_tokens: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "message";
        role: string;
        content: any[];
        id: string;
        model: string;
        stop_reason: string | null;
        stop_sequence: string | null;
        usage: {
            input_tokens: number;
            output_tokens: number;
        };
    }, {
        type: "message";
        role: string;
        content: any[];
        id: string;
        model: string;
        stop_reason: string | null;
        stop_sequence: string | null;
        usage: {
            input_tokens: number;
            output_tokens: number;
        };
    }>;
}, "strip", z.ZodTypeAny, {
    type: "message_start";
    message: {
        type: "message";
        role: string;
        content: any[];
        id: string;
        model: string;
        stop_reason: string | null;
        stop_sequence: string | null;
        usage: {
            input_tokens: number;
            output_tokens: number;
        };
    };
}, {
    type: "message_start";
    message: {
        type: "message";
        role: string;
        content: any[];
        id: string;
        model: string;
        stop_reason: string | null;
        stop_sequence: string | null;
        usage: {
            input_tokens: number;
            output_tokens: number;
        };
    };
}>;
declare const AnthropicStreamChatMessageDeltaResponse: z.ZodObject<{
    type: z.ZodLiteral<"message_delta">;
    delta: z.ZodObject<{
        stop_reason: z.ZodNullable<z.ZodString>;
        stop_sequence: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        stop_reason: string | null;
        stop_sequence: string | null;
    }, {
        stop_reason: string | null;
        stop_sequence: string | null;
    }>;
    usage: z.ZodObject<{
        output_tokens: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        output_tokens: number;
    }, {
        output_tokens: number;
    }>;
}, "strip", z.ZodTypeAny, {
    type: "message_delta";
    usage: {
        output_tokens: number;
    };
    delta: {
        stop_reason: string | null;
        stop_sequence: string | null;
    };
}, {
    type: "message_delta";
    usage: {
        output_tokens: number;
    };
    delta: {
        stop_reason: string | null;
        stop_sequence: string | null;
    };
}>;
declare const AnthropicStreamChatContentBlockStartResponse: z.ZodObject<{
    type: z.ZodLiteral<"content_block_start">;
    index: z.ZodNumber;
    content_block: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"text">;
        text: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool_use">;
        id: z.ZodString;
        name: z.ZodString;
        input: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
    }, "strip", z.ZodTypeAny, {
        type: "tool_use";
        name: string;
        id: string;
        input: {};
    }, {
        type: "tool_use";
        name: string;
        id: string;
        input: {};
    }>, z.ZodObject<{
        type: z.ZodLiteral<"thinking">;
        thinking: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "thinking";
        thinking: string;
    }, {
        type: "thinking";
        thinking: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"redacted_thinking">;
        data: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "redacted_thinking";
        data: string;
    }, {
        type: "redacted_thinking";
        data: string;
    }>]>;
}, "strip", z.ZodTypeAny, {
    type: "content_block_start";
    index: number;
    content_block: {
        type: "text";
        text: string;
    } | {
        type: "tool_use";
        name: string;
        id: string;
        input: {};
    } | {
        type: "thinking";
        thinking: string;
    } | {
        type: "redacted_thinking";
        data: string;
    };
}, {
    type: "content_block_start";
    index: number;
    content_block: {
        type: "text";
        text: string;
    } | {
        type: "tool_use";
        name: string;
        id: string;
        input: {};
    } | {
        type: "thinking";
        thinking: string;
    } | {
        type: "redacted_thinking";
        data: string;
    };
}>;
declare const AnthropicStreamChatContentBlockDeltaResponse: z.ZodObject<{
    type: z.ZodLiteral<"content_block_delta">;
    index: z.ZodNumber;
    delta: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"text_delta">;
        text: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "text_delta";
        text: string;
    }, {
        type: "text_delta";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"input_json_delta">;
        partial_json: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "input_json_delta";
        partial_json: string;
    }, {
        type: "input_json_delta";
        partial_json: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"thinking_delta">;
        thinking: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "thinking_delta";
        thinking: string;
    }, {
        type: "thinking_delta";
        thinking: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"signature_delta">;
        signature: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "signature_delta";
        signature: string;
    }, {
        type: "signature_delta";
        signature: string;
    }>]>;
}, "strip", z.ZodTypeAny, {
    type: "content_block_delta";
    index: number;
    delta: {
        type: "text_delta";
        text: string;
    } | {
        type: "input_json_delta";
        partial_json: string;
    } | {
        type: "thinking_delta";
        thinking: string;
    } | {
        type: "signature_delta";
        signature: string;
    };
}, {
    type: "content_block_delta";
    index: number;
    delta: {
        type: "text_delta";
        text: string;
    } | {
        type: "input_json_delta";
        partial_json: string;
    } | {
        type: "thinking_delta";
        thinking: string;
    } | {
        type: "signature_delta";
        signature: string;
    };
}>;

declare const AnthropicRequestThinkingContent: z.ZodObject<{
    type: z.ZodLiteral<"thinking">;
    thinking: z.ZodOptional<z.ZodString>;
    signature: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: "thinking";
    thinking?: string | undefined;
    signature?: string | undefined;
}, {
    type: "thinking";
    thinking?: string | undefined;
    signature?: string | undefined;
}>;
type AnthropicRequestThinkingContentType = z.infer<typeof AnthropicRequestThinkingContent>;
declare const AnthropicRequestRedactedThinkingContent: z.ZodObject<{
    type: z.ZodLiteral<"redacted_thinking">;
    data: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "redacted_thinking";
    data: string;
}, {
    type: "redacted_thinking";
    data: string;
}>;
type AnthropicRequestRedactedThinkingContentType = z.infer<typeof AnthropicRequestRedactedThinkingContent>;
declare const AnthropicRequestTool: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    input_schema: z.ZodAny;
}, "strip", z.ZodTypeAny, {
    name: string;
    description?: string | undefined;
    input_schema?: any;
}, {
    name: string;
    description?: string | undefined;
    input_schema?: any;
}>;
type AnthropicRequestToolType = z.infer<typeof AnthropicRequestTool>;
declare const AnthropicRequestToolChoiceEnum: z.ZodObject<{
    type: z.ZodEnum<["auto", "any"]>;
}, "strip", z.ZodTypeAny, {
    type: "auto" | "any";
}, {
    type: "auto" | "any";
}>;
type AnthropicRequestToolChoiceEnumType = z.infer<typeof AnthropicRequestToolChoiceEnum>;
declare const AnthropicRequestToolChoiceTool: z.ZodObject<{
    type: z.ZodLiteral<"tool">;
    name: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "tool";
    name: string;
}, {
    type: "tool";
    name: string;
}>;
type AnthropicRequestToolChoiceToolType = z.infer<typeof AnthropicRequestToolChoiceTool>;
declare const AnthropicRequestTextContent: z.ZodObject<{
    text: z.ZodString;
    type: z.ZodLiteral<"text">;
}, "strip", z.ZodTypeAny, {
    type: "text";
    text: string;
}, {
    type: "text";
    text: string;
}>;
type AnthropicRequestTextContentType = z.infer<typeof AnthropicRequestTextContent>;
declare const AnthropicRequestImageContent: z.ZodObject<{
    type: z.ZodLiteral<"image">;
    source: z.ZodObject<{
        type: z.ZodLiteral<"base64">;
        media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
        data: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "base64";
        data: string;
        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
    }, {
        type: "base64";
        data: string;
        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
    }>;
}, "strip", z.ZodTypeAny, {
    type: "image";
    source: {
        type: "base64";
        data: string;
        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
    };
}, {
    type: "image";
    source: {
        type: "base64";
        data: string;
        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
    };
}>;
type AnthropicRequestImageContentType = z.infer<typeof AnthropicRequestImageContent>;
declare const AnthropicRequestToolCallContent: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodLiteral<"tool_use">;
    name: z.ZodString;
    input: z.ZodRecord<z.ZodString, z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    type: "tool_use";
    name: string;
    id: string;
    input: Record<string, any>;
}, {
    type: "tool_use";
    name: string;
    id: string;
    input: Record<string, any>;
}>;
type AnthropicRequestToolCallContentType = z.infer<typeof AnthropicRequestToolCallContent>;
declare const AnthropicRequestToolResponseContent: z.ZodObject<{
    type: z.ZodLiteral<"tool_result">;
    tool_use_id: z.ZodString;
    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
        text: z.ZodString;
        type: z.ZodLiteral<"text">;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"image">;
        source: z.ZodObject<{
            type: z.ZodLiteral<"base64">;
            media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
            data: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        }, {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    }, {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    }>]>, "many">]>;
}, "strip", z.ZodTypeAny, {
    type: "tool_result";
    content: string | ({
        type: "text";
        text: string;
    } | {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    })[];
    tool_use_id: string;
}, {
    type: "tool_result";
    content: string | ({
        type: "text";
        text: string;
    } | {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    })[];
    tool_use_id: string;
}>;
type AnthropicRequestToolResponseContentType = z.infer<typeof AnthropicRequestToolResponseContent>;
declare const AnthropicRequestUserMessage: z.ZodObject<{
    role: z.ZodLiteral<"user">;
    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
        text: z.ZodString;
        type: z.ZodLiteral<"text">;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"image">;
        source: z.ZodObject<{
            type: z.ZodLiteral<"base64">;
            media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
            data: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        }, {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    }, {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool_result">;
        tool_use_id: z.ZodString;
        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
            text: z.ZodString;
            type: z.ZodLiteral<"text">;
        }, "strip", z.ZodTypeAny, {
            type: "text";
            text: string;
        }, {
            type: "text";
            text: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"image">;
            source: z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }>]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }>]>, "many">]>;
}, "strip", z.ZodTypeAny, {
    role: "user";
    content: string | ({
        type: "text";
        text: string;
    } | {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}, {
    role: "user";
    content: string | ({
        type: "text";
        text: string;
    } | {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}>;
type AnthropicRequestUserMessageType = z.infer<typeof AnthropicRequestUserMessage>;
declare const AnthropicRequestAssistantMessage: z.ZodObject<{
    role: z.ZodLiteral<"assistant">;
    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
        text: z.ZodString;
        type: z.ZodLiteral<"text">;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool_result">;
        tool_use_id: z.ZodString;
        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
            text: z.ZodString;
            type: z.ZodLiteral<"text">;
        }, "strip", z.ZodTypeAny, {
            type: "text";
            text: string;
        }, {
            type: "text";
            text: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"image">;
            source: z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }>]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"thinking">;
        thinking: z.ZodOptional<z.ZodString>;
        signature: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    }, {
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"redacted_thinking">;
        data: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "redacted_thinking";
        data: string;
    }, {
        type: "redacted_thinking";
        data: string;
    }>]>, "many">]>;
}, "strip", z.ZodTypeAny, {
    role: "assistant";
    content: string | ({
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    } | {
        type: "redacted_thinking";
        data: string;
    } | {
        type: "text";
        text: string;
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}, {
    role: "assistant";
    content: string | ({
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    } | {
        type: "redacted_thinking";
        data: string;
    } | {
        type: "text";
        text: string;
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}>;
type AnthropicRequestAssistantMessageType = z.infer<typeof AnthropicRequestAssistantMessage>;
declare const AnthropicRequestMessage: z.ZodUnion<[z.ZodObject<{
    role: z.ZodLiteral<"user">;
    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
        text: z.ZodString;
        type: z.ZodLiteral<"text">;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"image">;
        source: z.ZodObject<{
            type: z.ZodLiteral<"base64">;
            media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
            data: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        }, {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        }>;
    }, "strip", z.ZodTypeAny, {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    }, {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool_result">;
        tool_use_id: z.ZodString;
        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
            text: z.ZodString;
            type: z.ZodLiteral<"text">;
        }, "strip", z.ZodTypeAny, {
            type: "text";
            text: string;
        }, {
            type: "text";
            text: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"image">;
            source: z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }>]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }>]>, "many">]>;
}, "strip", z.ZodTypeAny, {
    role: "user";
    content: string | ({
        type: "text";
        text: string;
    } | {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}, {
    role: "user";
    content: string | ({
        type: "text";
        text: string;
    } | {
        type: "image";
        source: {
            type: "base64";
            data: string;
            media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
        };
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}>, z.ZodObject<{
    role: z.ZodLiteral<"assistant">;
    content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
        text: z.ZodString;
        type: z.ZodLiteral<"text">;
    }, "strip", z.ZodTypeAny, {
        type: "text";
        text: string;
    }, {
        type: "text";
        text: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool_result">;
        tool_use_id: z.ZodString;
        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
            text: z.ZodString;
            type: z.ZodLiteral<"text">;
        }, "strip", z.ZodTypeAny, {
            type: "text";
            text: string;
        }, {
            type: "text";
            text: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"image">;
            source: z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }>]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }, {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"thinking">;
        thinking: z.ZodOptional<z.ZodString>;
        signature: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    }, {
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"redacted_thinking">;
        data: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "redacted_thinking";
        data: string;
    }, {
        type: "redacted_thinking";
        data: string;
    }>]>, "many">]>;
}, "strip", z.ZodTypeAny, {
    role: "assistant";
    content: string | ({
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    } | {
        type: "redacted_thinking";
        data: string;
    } | {
        type: "text";
        text: string;
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}, {
    role: "assistant";
    content: string | ({
        type: "thinking";
        thinking?: string | undefined;
        signature?: string | undefined;
    } | {
        type: "redacted_thinking";
        data: string;
    } | {
        type: "text";
        text: string;
    } | {
        type: "tool_result";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        })[];
        tool_use_id: string;
    })[];
}>]>;
type AnthropicRequestMessageType = z.infer<typeof AnthropicRequestMessage>;
declare const AnthropicRequest: z.ZodObject<{
    model: z.ZodOptional<z.ZodString>;
    messages: z.ZodArray<z.ZodUnion<[z.ZodObject<{
        role: z.ZodLiteral<"user">;
        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
            text: z.ZodString;
            type: z.ZodLiteral<"text">;
        }, "strip", z.ZodTypeAny, {
            type: "text";
            text: string;
        }, {
            type: "text";
            text: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"image">;
            source: z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                data: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }, {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            }>;
        }, "strip", z.ZodTypeAny, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }, {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        }>, z.ZodObject<{
            type: z.ZodLiteral<"tool_result">;
            tool_use_id: z.ZodString;
            content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
                text: z.ZodString;
                type: z.ZodLiteral<"text">;
            }, "strip", z.ZodTypeAny, {
                type: "text";
                text: string;
            }, {
                type: "text";
                text: string;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"image">;
                source: z.ZodObject<{
                    type: z.ZodLiteral<"base64">;
                    media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                    data: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                }, {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                }>;
            }, "strip", z.ZodTypeAny, {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            }, {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            }>]>, "many">]>;
        }, "strip", z.ZodTypeAny, {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        }, {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        }>]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    }, {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    }>, z.ZodObject<{
        role: z.ZodLiteral<"assistant">;
        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
            text: z.ZodString;
            type: z.ZodLiteral<"text">;
        }, "strip", z.ZodTypeAny, {
            type: "text";
            text: string;
        }, {
            type: "text";
            text: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"tool_result">;
            tool_use_id: z.ZodString;
            content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
                text: z.ZodString;
                type: z.ZodLiteral<"text">;
            }, "strip", z.ZodTypeAny, {
                type: "text";
                text: string;
            }, {
                type: "text";
                text: string;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"image">;
                source: z.ZodObject<{
                    type: z.ZodLiteral<"base64">;
                    media_type: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
                    data: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                }, {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                }>;
            }, "strip", z.ZodTypeAny, {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            }, {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            }>]>, "many">]>;
        }, "strip", z.ZodTypeAny, {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        }, {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"thinking">;
            thinking: z.ZodOptional<z.ZodString>;
            signature: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "thinking";
            thinking?: string | undefined;
            signature?: string | undefined;
        }, {
            type: "thinking";
            thinking?: string | undefined;
            signature?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"redacted_thinking">;
            data: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "redacted_thinking";
            data: string;
        }, {
            type: "redacted_thinking";
            data: string;
        }>]>, "many">]>;
    }, "strip", z.ZodTypeAny, {
        role: "assistant";
        content: string | ({
            type: "thinking";
            thinking?: string | undefined;
            signature?: string | undefined;
        } | {
            type: "redacted_thinking";
            data: string;
        } | {
            type: "text";
            text: string;
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    }, {
        role: "assistant";
        content: string | ({
            type: "thinking";
            thinking?: string | undefined;
            signature?: string | undefined;
        } | {
            type: "redacted_thinking";
            data: string;
        } | {
            type: "text";
            text: string;
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    }>]>, "many">;
    system: z.ZodOptional<z.ZodString>;
    max_tokens: z.ZodOptional<z.ZodNumber>;
    stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    temperature: z.ZodOptional<z.ZodNumber>;
    tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
        type: z.ZodEnum<["auto", "any"]>;
    }, "strip", z.ZodTypeAny, {
        type: "auto" | "any";
    }, {
        type: "auto" | "any";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"tool">;
        name: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "tool";
        name: string;
    }, {
        type: "tool";
        name: string;
    }>]>>;
    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        input_schema: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        name: string;
        description?: string | undefined;
        input_schema?: any;
    }, {
        name: string;
        description?: string | undefined;
        input_schema?: any;
    }>, "many">>;
    top_p: z.ZodOptional<z.ZodNumber>;
    top_k: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    messages: ({
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    } | {
        role: "assistant";
        content: string | ({
            type: "thinking";
            thinking?: string | undefined;
            signature?: string | undefined;
        } | {
            type: "redacted_thinking";
            data: string;
        } | {
            type: "text";
            text: string;
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    })[];
    temperature?: number | undefined;
    top_p?: number | undefined;
    top_k?: number | undefined;
    tool_choice?: {
        type: "auto" | "any";
    } | {
        type: "tool";
        name: string;
    } | undefined;
    max_tokens?: number | undefined;
    stop_sequences?: string[] | undefined;
    system?: string | undefined;
    model?: string | undefined;
    tools?: {
        name: string;
        description?: string | undefined;
        input_schema?: any;
    }[] | undefined;
}, {
    messages: ({
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "base64";
                data: string;
                media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
            };
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    } | {
        role: "assistant";
        content: string | ({
            type: "thinking";
            thinking?: string | undefined;
            signature?: string | undefined;
        } | {
            type: "redacted_thinking";
            data: string;
        } | {
            type: "text";
            text: string;
        } | {
            type: "tool_result";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "base64";
                    data: string;
                    media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
                };
            })[];
            tool_use_id: string;
        })[];
    })[];
    temperature?: number | undefined;
    top_p?: number | undefined;
    top_k?: number | undefined;
    tool_choice?: {
        type: "auto" | "any";
    } | {
        type: "tool";
        name: string;
    } | undefined;
    max_tokens?: number | undefined;
    stop_sequences?: string[] | undefined;
    system?: string | undefined;
    model?: string | undefined;
    tools?: {
        name: string;
        description?: string | undefined;
        input_schema?: any;
    }[] | undefined;
}>;
type AnthropicRequestType = z.infer<typeof AnthropicRequest>;

declare const AnthropicEmbeddingModelModalities: EmbeddingModelSchemaType["modalities"];
declare const AnthropicEmbeddingModelModalitiesEnum: z.ZodEnum<["text"]>;

declare const AnthropicGetEmbeddingsResponse: z.ZodObject<{
    object: z.ZodLiteral<"list">;
    model: z.ZodString;
    data: z.ZodArray<z.ZodObject<{
        index: z.ZodNumber;
        object: z.ZodLiteral<"embedding">;
        embedding: z.ZodUnion<[z.ZodArray<z.ZodNumber, "many">, z.ZodString]>;
    }, "strip", z.ZodTypeAny, {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }, {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }>, "many">;
    usage: z.ZodObject<{
        total_tokens: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        total_tokens: number;
    }, {
        total_tokens: number;
    }>;
}, "strip", z.ZodTypeAny, {
    object: "list";
    data: {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }[];
    model: string;
    usage: {
        total_tokens: number;
    };
}, {
    object: "list";
    data: {
        object: "embedding";
        index: number;
        embedding: string | number[];
    }[];
    model: string;
    usage: {
        total_tokens: number;
    };
}>;

declare const AnthropicEmbeddingRequestInput: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
type AnthropicEmbeddingRequestInputType = z.infer<typeof AnthropicEmbeddingRequestInput>;
declare const AnthropicEmbeddingRequest: z.ZodObject<{
    model: z.ZodOptional<z.ZodString>;
    input: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
    encoding_format: z.ZodOptional<z.ZodNullable<z.ZodEnum<["base64"]>>>;
    input_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<["query", "document"]>>>;
    truncation: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    input: string | string[];
    encoding_format?: "base64" | null | undefined;
    input_type?: "query" | "document" | null | undefined;
    truncation?: boolean | undefined;
    model?: string | undefined;
}, {
    input: string | string[];
    encoding_format?: "base64" | null | undefined;
    input_type?: "query" | "document" | null | undefined;
    truncation?: boolean | undefined;
    model?: string | undefined;
}>;
type AnthropicEmbeddingRequestType = z.infer<typeof AnthropicEmbeddingRequest>;

declare const BaseEmbeddingModelOptions: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type BaseEmbeddingModelOptionsType = z.infer<typeof BaseEmbeddingModelOptions>;
declare class BaseEmbeddingModel implements EmbeddingModelV1<EmbeddingModelSchemaType> {
    readonly version: "v1";
    modelSchema: EmbeddingModelSchemaType;
    readonly modelName: string;
    private readonly apiKey;
    private readonly baseUrl;
    private readonly getEmbeddingsUrl;
    constructor(modelSchema: EmbeddingModelSchemaType, options: BaseEmbeddingModelOptionsType);
    getDefaultBaseUrl(): UrlType;
    getDefaultHeaders(): HeadersType;
    getDefaultParams(): ParamsType;
    getTokenCount(requests: EmbeddingRequestsType): number;
    getRetryDelay(responseHeaders: HeadersType): {
        shouldRetry: boolean;
        delayMs: number;
    };
    transformModelRequest(request: any): {
        modelName: string | undefined;
        config: ConfigType;
        embeddingRequests: EmbeddingRequestsType;
    };
    transformConfig(config: ConfigType, requests?: EmbeddingRequestsType): ParamsType;
    transformEmbeddingRequests(requests: EmbeddingRequestsType): ParamsType;
    getGetEmbeddingsUrl(config?: ConfigType, requests?: EmbeddingRequestsType): Promise<UrlType>;
    getGetEmbeddingsHeaders(config?: ConfigType, requests?: EmbeddingRequestsType): Promise<HeadersType>;
    getGetEmbeddingsData(config: ConfigType, requests: EmbeddingRequestsType): Promise<ParamsType>;
    transformGetEmbeddingsResponse(response: any): EmbeddingResponseType;
}

declare const VoyageCode2Literal = "voyage-code-2";
declare const VoyageCode2Schema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const VoyageCode2Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type VoyageCode2OptionsType = z.infer<typeof VoyageCode2Options>;
declare class VoyageCode2 extends BaseEmbeddingModel {
    constructor(options: VoyageCode2OptionsType);
}

declare const VoyageLaw2Literal = "voyage-law-2";
declare const VoyageLaw2Schema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const VoyageLaw2Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type VoyageLaw2OptionsType = z.infer<typeof VoyageLaw2Options>;
declare class VoyageLaw2 extends BaseEmbeddingModel {
    constructor(options: VoyageLaw2OptionsType);
}

declare const VoyageMultilingual2Literal = "voyage-multilingual-2";
declare const VoyageMultilingual2Schema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const VoyageMultilingual2Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type VoyageMultilingual2OptionsType = z.infer<typeof VoyageMultilingual2Options>;
declare class VoyageMultilingual2 extends BaseEmbeddingModel {
    constructor(options: VoyageMultilingual2OptionsType);
}

declare const VoyageFinance2Literal = "voyage-finance-2";
declare const VoyageFinance2Schema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const VoyageFinance2Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type VoyageFinance2OptionsType = z.infer<typeof VoyageFinance2Options>;
declare class VoyageFinance2 extends BaseEmbeddingModel {
    constructor(options: VoyageFinance2OptionsType);
}

declare const Voyage3LiteLiteral = "voyage-3-lite";
declare const Voyage3LiteSchema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const Voyage3LiteOptions: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type Voyage3LiteOptionsType = z.infer<typeof Voyage3LiteOptions>;
declare class Voyage3Lite extends BaseEmbeddingModel {
    constructor(options: Voyage3LiteOptionsType);
}

declare const Voyage3Literal = "voyage-3";
declare const Voyage3Schema: {
    description: string;
    name: string;
    modalities: ["text", ..."text"[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        } | {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        } | {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const Voyage3Options: z.ZodObject<{
    modelName: z.ZodString;
    apiKey: z.ZodString;
    getEmbeddingsUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}, {
    modelName: string;
    apiKey: string;
    getEmbeddingsUrl?: string | undefined;
}>;
type Voyage3OptionsType = z.infer<typeof Voyage3Options>;
declare class Voyage3 extends BaseEmbeddingModel {
    constructor(options: Voyage3OptionsType);
}

declare const ProviderLiteral = "anthropic";
declare class Anthropic<C extends BaseChatModelOptionsType, E extends BaseEmbeddingModelOptionsType> implements ProviderV1<C, E> {
    readonly version: "v1";
    readonly name = "anthropic";
    static readonly chatBaseUrl: string;
    static readonly embeddingBaseUrl: string;
    private readonly chatModelFactories;
    private readonly embeddingModelFactories;
    chatModelLiterals(): string[];
    chatModelSchemas(): Record<string, ChatModelSchemaType>;
    chatModel(options: C): ChatModelV1;
    embeddingModelLiterals(): string[];
    embeddingModelSchemas(): Record<string, EmbeddingModelSchemaType>;
    embeddingModel(options: E): EmbeddingModelV1;
}

export { Anthropic, AnthropicChatModelConfigs, AnthropicChatModelModalities, AnthropicChatModelModalitiesEnum, AnthropicChatModelRoles, AnthropicChatModelRolesMap, AnthropicCompleteChatResponse, type AnthropicCompleteChatResponseType, AnthropicEmbeddingModelConfigs, AnthropicEmbeddingModelModalities, AnthropicEmbeddingModelModalitiesEnum, AnthropicEmbeddingRequest, AnthropicEmbeddingRequestInput, type AnthropicEmbeddingRequestInputType, type AnthropicEmbeddingRequestType, AnthropicGetEmbeddingsResponse, AnthropicRequest, AnthropicRequestAssistantMessage, type AnthropicRequestAssistantMessageType, AnthropicRequestImageContent, type AnthropicRequestImageContentType, AnthropicRequestMessage, type AnthropicRequestMessageType, AnthropicRequestRedactedThinkingContent, type AnthropicRequestRedactedThinkingContentType, AnthropicRequestTextContent, type AnthropicRequestTextContentType, AnthropicRequestThinkingContent, type AnthropicRequestThinkingContentType, AnthropicRequestTool, AnthropicRequestToolCallContent, type AnthropicRequestToolCallContentType, AnthropicRequestToolChoiceEnum, type AnthropicRequestToolChoiceEnumType, AnthropicRequestToolChoiceTool, type AnthropicRequestToolChoiceToolType, AnthropicRequestToolResponseContent, type AnthropicRequestToolResponseContentType, type AnthropicRequestToolType, type AnthropicRequestType, AnthropicRequestUserMessage, type AnthropicRequestUserMessageType, AnthropicStreamChatContentBlockDeltaResponse, AnthropicStreamChatContentBlockStartResponse, AnthropicStreamChatMessageDeltaResponse, AnthropicStreamChatMessageStartResponse, AnthropicThinkingChatModelModalities, AnthropicThinkingChatModelModalitiesEnum, BaseChatModel, BaseChatModelOptions, type BaseChatModelOptionsType, BaseEmbeddingModel, BaseEmbeddingModelOptions, type BaseEmbeddingModelOptionsType, ChatModelBaseConfigDef, ChatModelBaseConfigSchema, ChatModelReasoningConfigDef, ChatModelReasoningConfigSchema, Claude3Haiku20240307, Claude3Haiku20240307Literal, Claude3Haiku20240307Options, type Claude3Haiku20240307OptionsType, Claude3Haiku20240307Schema, Claude3Opus20240229, Claude3Opus20240229Literal, Claude3Opus20240229Options, type Claude3Opus20240229OptionsType, Claude3Opus20240229Schema, Claude3Sonnet20240229, Claude3Sonnet20240229Literal, Claude3Sonnet20240229Options, type Claude3Sonnet20240229OptionsType, Claude3Sonnet20240229Schema, Claude3_5Haiku20241022, Claude3_5Haiku20241022Literal, Claude3_5Haiku20241022Options, type Claude3_5Haiku20241022OptionsType, Claude3_5Haiku20241022Schema, Claude3_5Sonnet20240620, Claude3_5Sonnet20240620Literal, Claude3_5Sonnet20240620Options, type Claude3_5Sonnet20240620OptionsType, Claude3_5Sonnet20240620Schema, Claude3_5Sonnet20241022, Claude3_5Sonnet20241022Literal, Claude3_5Sonnet20241022Options, type Claude3_5Sonnet20241022OptionsType, Claude3_5Sonnet20241022Schema, Claude3_7Sonnet20250219, Claude3_7Sonnet20250219Literal, Claude3_7Sonnet20250219Options, type Claude3_7Sonnet20250219OptionsType, Claude3_7Sonnet20250219Schema, Claude4Opus20250514, Claude4Opus20250514Literal, Claude4Opus20250514Options, type Claude4Opus20250514OptionsType, Claude4Opus20250514Schema, Claude4Sonnet20250514, Claude4Sonnet20250514Literal, Claude4Sonnet20250514Options, type Claude4Sonnet20250514OptionsType, Claude4Sonnet20250514Schema, EmbeddingModelBaseConfigDef, EmbeddingModelBaseConfigSchema, ProviderLiteral, Voyage3, Voyage3Lite, Voyage3LiteLiteral, Voyage3LiteOptions, type Voyage3LiteOptionsType, Voyage3LiteSchema, Voyage3Literal, Voyage3Options, type Voyage3OptionsType, Voyage3Schema, VoyageCode2, VoyageCode2Literal, VoyageCode2Options, type VoyageCode2OptionsType, VoyageCode2Schema, VoyageFinance2, VoyageFinance2Literal, VoyageFinance2Options, type VoyageFinance2OptionsType, VoyageFinance2Schema, VoyageLaw2, VoyageLaw2Literal, VoyageLaw2Options, type VoyageLaw2OptionsType, VoyageLaw2Schema, VoyageMultilingual2, VoyageMultilingual2Literal, VoyageMultilingual2Options, type VoyageMultilingual2OptionsType, VoyageMultilingual2Schema, encodingFormat, inputType, maxTokens, stop, temperature, toolChoice, topK, topP, truncation };