import { GatewayBaseError, RoleEnum, ModalityEnum, MessageType, ConfigType, ToolType, ChatResponseType, PartialChatResponseType, ChatModelPriceType, EmbeddingModalityEnum, EmbeddingRequestsType, EmbeddingResponseType } from '@adaline/types';
import { z } from 'zod';

declare class ProviderError extends GatewayBaseError {
    readonly name: "ProviderError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isProviderError(error: unknown): error is ProviderError;
}

declare class ModelError extends GatewayBaseError {
    readonly name: "ModelError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isModelError(error: unknown): error is ModelError;
}

declare class ModelResponseError extends GatewayBaseError {
    readonly name: "ModelResponseError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isModelResponseError(error: unknown): error is ModelResponseError;
}

declare class InvalidModelRequestError extends GatewayBaseError {
    readonly name: "InvalidModelRequestError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isInvalidModelRequestError(error: unknown): error is InvalidModelRequestError;
}

declare class InvalidConfigError extends GatewayBaseError {
    readonly name: "InvalidConfigError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isInvalidConfigError(error: unknown): error is InvalidConfigError;
}

declare class InvalidMessagesError extends GatewayBaseError {
    readonly name: "InvalidMessagesError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isInvalidMessagesError(error: unknown): error is InvalidMessagesError;
}

declare class InvalidToolsError extends GatewayBaseError {
    readonly name: "InvalidToolsError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isInvalidToolsError(error: unknown): error is InvalidToolsError;
}

declare class InvalidEmbeddingRequestsError extends GatewayBaseError {
    readonly name: "InvalidEmbeddingRequestsError";
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isInvalidEmbeddingRequestsError(error: unknown): error is InvalidEmbeddingRequestsError;
}

declare const ChatModelSchema: <R extends z.ZodEnum<[string, ...string[]]> = z.ZodEnum<["system", "user", "assistant", "tool"]>, M extends z.ZodEnum<[string, ...string[]]> = z.ZodEnum<["text", "image", "tool-call", "tool-response", "reasoning"]>>(Roles?: R, Modalities?: M) => z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    roles: z.ZodRecord<R, z.ZodOptional<z.ZodString>>;
    modalities: z.ZodArray<M, "atleastone">;
    maxInputTokens: z.ZodNumber;
    maxOutputTokens: z.ZodNumber;
    maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
    config: z.ZodEffects<z.ZodObject<{
        def: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"range">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            min: z.ZodNumber;
            max: z.ZodNumber;
            step: z.ZodNumber;
            default: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multi-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodString;
            choices: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-boolean">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodNullable<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"object-schema">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            objectSchema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }>]>>;
        schema: z.ZodType<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>, z.ZodTypeDef, z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>>;
    }, "strip", z.ZodTypeAny, {
        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>;
    }, {
        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>;
    }>, {
        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>;
    }, {
        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: z.ZodType<{
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }, z.ZodTypeDef, {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }>;
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    roles: z.ZodRecord<R, z.ZodOptional<z.ZodString>>;
    modalities: z.ZodArray<M, "atleastone">;
    maxInputTokens: z.ZodNumber;
    maxOutputTokens: z.ZodNumber;
    maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
    config: z.ZodEffects<z.ZodObject<{
        def: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"range">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            min: z.ZodNumber;
            max: z.ZodNumber;
            step: z.ZodNumber;
            default: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multi-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodString;
            choices: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-boolean">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodNullable<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"object-schema">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            objectSchema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }>]>>;
        schema: z.ZodType<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>, z.ZodTypeDef, z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>>;
    }, "strip", z.ZodTypeAny, {
        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>;
    }, {
        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>;
    }>, {
        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>;
    }, {
        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: z.ZodType<{
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }, z.ZodTypeDef, {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }>;
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
    name: z.ZodString;
    description: z.ZodString;
    roles: z.ZodRecord<R, z.ZodOptional<z.ZodString>>;
    modalities: z.ZodArray<M, "atleastone">;
    maxInputTokens: z.ZodNumber;
    maxOutputTokens: z.ZodNumber;
    maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
    config: z.ZodEffects<z.ZodObject<{
        def: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"range">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            min: z.ZodNumber;
            max: z.ZodNumber;
            step: z.ZodNumber;
            default: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multi-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodString;
            choices: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-boolean">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodNullable<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"object-schema">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            objectSchema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }>]>>;
        schema: z.ZodType<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>, z.ZodTypeDef, z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>>;
    }, "strip", z.ZodTypeAny, {
        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>;
    }, {
        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>;
    }>, {
        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>;
    }, {
        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: z.ZodType<{
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }, z.ZodTypeDef, {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }>;
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
    name: z.ZodString;
    description: z.ZodString;
    roles: z.ZodRecord<R, z.ZodOptional<z.ZodString>>;
    modalities: z.ZodArray<M, "atleastone">;
    maxInputTokens: z.ZodNumber;
    maxOutputTokens: z.ZodNumber;
    maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
    config: z.ZodEffects<z.ZodObject<{
        def: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"range">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            min: z.ZodNumber;
            max: z.ZodNumber;
            step: z.ZodNumber;
            default: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multi-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodString;
            choices: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-boolean">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodNullable<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"object-schema">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            objectSchema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }>]>>;
        schema: z.ZodType<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>, z.ZodTypeDef, z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>>;
    }, "strip", z.ZodTypeAny, {
        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>;
    }, {
        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>;
    }>, {
        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>;
    }, {
        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: z.ZodType<{
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }, z.ZodTypeDef, {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }>;
}>]: z.baseObjectInputType<{
    name: z.ZodString;
    description: z.ZodString;
    roles: z.ZodRecord<R, z.ZodOptional<z.ZodString>>;
    modalities: z.ZodArray<M, "atleastone">;
    maxInputTokens: z.ZodNumber;
    maxOutputTokens: z.ZodNumber;
    maxReasoningTokens: z.ZodOptional<z.ZodNumber>;
    config: z.ZodEffects<z.ZodObject<{
        def: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"range">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            min: z.ZodNumber;
            max: z.ZodNumber;
            step: z.ZodNumber;
            default: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multi-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodString;
            choices: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-boolean">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodNullable<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"object-schema">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            objectSchema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }>]>>;
        schema: z.ZodType<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>, z.ZodTypeDef, z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>>;
    }, "strip", z.ZodTypeAny, {
        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>;
    }, {
        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>;
    }>, {
        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>;
    }, {
        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: z.ZodType<{
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }, z.ZodTypeDef, {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    }>;
}>[k_1]; }>;
type ChatModelSchemaType<R extends z.ZodEnum<[string, ...string[]]> = typeof RoleEnum, M extends z.ZodEnum<[string, ...string[]]> = typeof ModalityEnum> = z.infer<ReturnType<typeof ChatModelSchema<R, M>>>;

declare const Headers: z.ZodRecord<z.ZodString, z.ZodString>;
type HeadersType = z.infer<typeof Headers>;

declare const Params: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodString, z.ZodNumber, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull, z.ZodUndefined]>>;
type ParamsType = z.infer<typeof Params>;

declare const Url: z.ZodString;
type UrlType = z.infer<typeof Url>;

declare const ConfigItemLiterals: readonly ["range", "multi-string", "select-string", "object-schema", "select-boolean"];
declare const ConfigItemEnum: z.ZodEnum<["range", "multi-string", "select-string", "object-schema", "select-boolean"]>;
type ConfigItemEnumType = z.infer<typeof ConfigItemEnum>;
declare const ConfigItemDef: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
    type: z.ZodLiteral<"range">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    min: z.ZodNumber;
    max: z.ZodNumber;
    step: z.ZodNumber;
    default: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "range";
    param: string;
    title: string;
    description: string;
    max: number;
    default: number;
    min: number;
    step: number;
}, {
    type: "range";
    param: string;
    title: string;
    description: string;
    max: number;
    default: number;
    min: number;
    step: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"multi-string">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    max: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "multi-string";
    param: string;
    title: string;
    description: string;
    max: number;
}, {
    type: "multi-string";
    param: string;
    title: string;
    description: string;
    max: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"select-string">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    default: z.ZodString;
    choices: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    type: "select-string";
    param: string;
    title: string;
    description: string;
    default: string;
    choices: string[];
}, {
    type: "select-string";
    param: string;
    title: string;
    description: string;
    default: string;
    choices: string[];
}>, z.ZodObject<{
    type: z.ZodLiteral<"select-boolean">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    default: z.ZodNullable<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "select-boolean";
    param: string;
    title: string;
    description: string;
    default: boolean | null;
}, {
    type: "select-boolean";
    param: string;
    title: string;
    description: string;
    default: boolean | null;
}>, z.ZodObject<{
    type: z.ZodLiteral<"object-schema">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    objectSchema: z.ZodAny;
}, "strip", z.ZodTypeAny, {
    type: "object-schema";
    param: string;
    title: string;
    description: string;
    objectSchema?: any;
}, {
    type: "object-schema";
    param: string;
    title: string;
    description: string;
    objectSchema?: any;
}>]>;
type ConfigItemDefType = z.infer<typeof ConfigItemDef>;

declare const MultiStringConfigItemTypeLiteral: "multi-string";
declare const MultiStringConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"multi-string">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    max: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "multi-string";
    param: string;
    title: string;
    description: string;
    max: number;
}, {
    type: "multi-string";
    param: string;
    title: string;
    description: string;
    max: number;
}>;
type MultiStringConfigItemType = z.infer<typeof MultiStringConfigItemDef>;
declare const MultiStringConfigItemSchema: (max: number) => z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
type MultiStringConfigItemSchemaType = z.infer<ReturnType<typeof MultiStringConfigItemSchema>>;
declare const MultiStringConfigItem: (data: Omit<MultiStringConfigItemType, "type">) => {
    def: {
        type: "multi-string";
        param: string;
        title: string;
        description: string;
        max: number;
    };
    schema: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
};

declare const RangeConfigItemTypeLiteral: "range";
declare const RangeConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"range">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    min: z.ZodNumber;
    max: z.ZodNumber;
    step: z.ZodNumber;
    default: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "range";
    param: string;
    title: string;
    description: string;
    max: number;
    default: number;
    min: number;
    step: number;
}, {
    type: "range";
    param: string;
    title: string;
    description: string;
    max: number;
    default: number;
    min: number;
    step: number;
}>;
type RangeConfigItemDefType = z.infer<typeof RangeConfigItemDef>;
declare const RangeConfigItemSchema: (min: number, max: number, step: number, defaultValue: number) => z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
type RangeConfigItemSchemaType = z.infer<ReturnType<typeof RangeConfigItemSchema>>;
declare const RangeConfigItem: (data: Omit<RangeConfigItemDefType, "type">) => {
    def: {
        type: "range";
        param: string;
        title: string;
        description: string;
        max: number;
        default: number;
        min: number;
        step: number;
    };
    schema: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
};

declare const SelectStringConfigItemTypeLiteral: "select-string";
declare const SelectStringConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"select-string">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    default: z.ZodString;
    choices: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    type: "select-string";
    param: string;
    title: string;
    description: string;
    default: string;
    choices: string[];
}, {
    type: "select-string";
    param: string;
    title: string;
    description: string;
    default: string;
    choices: string[];
}>;
type SelectStringConfigItemDefType = z.infer<typeof SelectStringConfigItemDef>;
declare const SelectStringConfigItemSchema: (defaultValue: string | null, choices: string[]) => z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
type SelectStringConfigItemSchemaType = z.infer<ReturnType<typeof SelectStringConfigItemSchema>>;
declare const SelectStringConfigItem: (data: Omit<SelectStringConfigItemDefType, "type">) => {
    def: {
        type: "select-string";
        param: string;
        title: string;
        description: string;
        default: string;
        choices: string[];
    };
    schema: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodEnum<[string, ...string[]]>>>>;
};

declare const SelectBooleanConfigItemTypeLiteral: "select-boolean";
declare const SelectBooleanConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"select-boolean">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    default: z.ZodNullable<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    type: "select-boolean";
    param: string;
    title: string;
    description: string;
    default: boolean | null;
}, {
    type: "select-boolean";
    param: string;
    title: string;
    description: string;
    default: boolean | null;
}>;
type SelectBooleanConfigItemDefType = z.infer<typeof SelectBooleanConfigItemDef>;
declare const SelectBooleanConfigItemSchema: (defaultValue: boolean | null) => z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodBoolean>>>;
type SelectBooleanConfigItemSchemaType = z.infer<ReturnType<typeof SelectBooleanConfigItemSchema>>;
declare const SelectBooleanConfigItem: (data: Omit<SelectBooleanConfigItemDefType, "type">) => {
    def: {
        type: "select-boolean";
        param: string;
        title: string;
        description: string;
        default: boolean | null;
    };
    schema: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodBoolean>>>;
};

declare const ObjectSchemaConfigItemTypeLiteral: "object-schema";
declare const ObjectSchemaConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"object-schema">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    objectSchema: z.ZodAny;
}, "strip", z.ZodTypeAny, {
    type: "object-schema";
    param: string;
    title: string;
    description: string;
    objectSchema?: any;
}, {
    type: "object-schema";
    param: string;
    title: string;
    description: string;
    objectSchema?: any;
}>;
type ObjectSchemaConfigItemType = z.infer<typeof ObjectSchemaConfigItemDef>;
declare const ObjectSchemaConfigItemSchema: <S extends z.ZodRawShape>(schema: z.ZodObject<S>) => z.ZodOptional<z.ZodObject<S, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<S>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<S>, any>[k]; } : never, z.baseObjectInputType<S> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<S>[k_1]; } : never>>;
type ObjectSchemaConfigItemSchemaType<S extends z.ZodRawShape = z.ZodRawShape> = z.infer<ReturnType<typeof ObjectSchemaConfigItemSchema<S>>>;
declare const ObjectSchemaConfigItem: (data: Omit<ObjectSchemaConfigItemType, "type">) => {
    def: {
        type: "object-schema";
        param: string;
        title: string;
        description: string;
        objectSchema?: any;
    };
    schema: z.ZodOptional<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, {
        [x: string]: any;
    }, {
        [x: string]: any;
    }>>;
};

interface ChatModelV1<MS extends ChatModelSchemaType = ChatModelSchemaType> {
    readonly version: "v1";
    readonly modelSchema: MS;
    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;
    }>;
    getProxyStreamChatUrl(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<UrlType>;
    getProxyStreamChatHeaders(data?: any, headers?: Record<string, string>, query?: Record<string, string>): Promise<HeadersType>;
    transformProxyStreamChatResponseChunk(chunk: string, buffer: string, data?: any, headers?: Record<string, string>, query?: Record<string, string>): AsyncGenerator<{
        partialResponse: PartialChatResponseType;
        buffer: string;
    }>;
    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>;
    getModelPricing(): ChatModelPriceType;
}

declare const EmbeddingModelSchema: <M extends z.ZodEnum<[string, ...string[]]> = z.ZodEnum<["text", "token"]>>(Modalities?: M) => z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    modalities: z.ZodArray<M, "atleastone">;
    maxInputTokens: z.ZodNumber;
    maxOutputTokens: z.ZodNumber;
    config: z.ZodEffects<z.ZodObject<{
        def: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"range">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            min: z.ZodNumber;
            max: z.ZodNumber;
            step: z.ZodNumber;
            default: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }, {
            type: "range";
            param: string;
            title: string;
            description: string;
            max: number;
            default: number;
            min: number;
            step: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"multi-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            max: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodString;
            choices: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }, {
            type: "select-string";
            param: string;
            title: string;
            description: string;
            default: string;
            choices: string[];
        }>, z.ZodObject<{
            type: z.ZodLiteral<"select-boolean">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodNullable<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }, {
            type: "select-boolean";
            param: string;
            title: string;
            description: string;
            default: boolean | null;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"object-schema">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            objectSchema: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }, {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        }>]>>;
        schema: z.ZodType<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>, z.ZodTypeDef, z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>>;
    }, "strip", z.ZodTypeAny, {
        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>;
    }, {
        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>;
    }>, {
        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>;
    }, {
        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>;
    }>;
}, "strip", z.ZodTypeAny, {
    description: string;
    name: string;
    modalities: [M["_output"], ...M["_output"][]];
    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>;
    };
}, {
    description: string;
    name: string;
    modalities: [M["_input"], ...M["_input"][]];
    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>;
    };
}>;
type EmbeddingModelSchemaType<M extends z.ZodEnum<[string, ...string[]]> = typeof EmbeddingModalityEnum> = z.infer<ReturnType<typeof EmbeddingModelSchema<M>>>;

interface EmbeddingModelV1<MS extends EmbeddingModelSchemaType = EmbeddingModelSchemaType> {
    readonly version: "v1";
    readonly modelSchema: MS;
    getDefaultBaseUrl(): UrlType;
    getDefaultHeaders(): HeadersType;
    getDefaultParams(): ParamsType;
    getRetryDelay(responseHeaders: HeadersType): {
        shouldRetry: boolean;
        delayMs: number;
    };
    getTokenCount(requests: EmbeddingRequestsType): 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;
}

interface ProviderV1<C extends Record<string, any> = Record<string, any>, E extends Record<string, any> = Record<string, any>> {
    readonly version: "v1";
    readonly name: string;
    chatModelLiterals(): string[];
    chatModelSchemas(): Record<string, ChatModelSchemaType>;
    chatModel(options: C): ChatModelV1;
    embeddingModelLiterals(): string[];
    embeddingModelSchemas(): Record<string, EmbeddingModelSchemaType>;
    embeddingModel(options: E): EmbeddingModelV1;
}

declare const CHAT_CONFIG: {
    TEMPERATURE: {
        readonly type: "range";
        readonly title: "Temperature";
        readonly description: "Adjusts the model's creativity level. With a setting of 0, the model strictly picks the most probable next word.     For endeavors that benefit from a dash of inventiveness, consider dialing it up to 0.7 or higher, enabling the model to produce text     that's unexpectedly fresh.";
    };
    MAX_TOKENS: {
        readonly type: "range";
        readonly title: "Max tokens";
        readonly description: "Specify the total tokens for generation, where one token approximates four English characters.     Setting this to 0 defaults to the model's maximum capacity.";
    };
    STOP: (max: number) => {
        readonly type: "multi";
        readonly title: "Stop sequence";
        readonly description: `Enter up to ${number} sequences that will halt additional text output.       The generated text will exclude these sequences.`;
    };
    TOP_A: {
        readonly type: "range";
        readonly title: "Top A";
        readonly description: "Considers only the top tokens that have 'sufficiently high' probabilities relative to the most likely token,     functioning like a dynamic Top-P.     A lower Top-A value narrows down the token choices based on the highest probability token,     while a higher Top-A value refines the filtering without necessarily impacting the creativity of the output.";
    };
    TOP_P: {
        readonly type: "range";
        readonly title: "Top P";
        readonly description: "Selects a subset of likely tokens for generation, restricting choices to the top-P fraction of possibilities,     such as the top 10% when P=0.1.     This approach can limit the variety of the output. By default, it's set to 1, indicating no restriction.     It's advised to adjust this parameter or temperature to modulate output diversity, but not to modify both simultaneously.";
    };
    TOP_K: {
        readonly type: "range";
        readonly title: "Top K";
        readonly description: "Select only from the highest K probabilities for each following word, effectively eliminating the less likely 'long tail' options.";
    };
    MIN_P: {
        readonly type: "range";
        readonly title: "Min P";
        readonly description: "Specifies the minimum probability a token must have to be considered, in relation to the probability of the most likely token.     (This value varies based on the confidence level of the top token.)     For example, if Min-P is set to 0.1, only tokens with at least 1/10th the probability of the highest-ranked token will be considered.";
    };
    FREQUENCY_PENALTY: {
        readonly type: "range";
        readonly title: "Frequency penalty";
        readonly description: "Minimize redundancy.    By assigning a penalty to frequently used tokens within the text, the likelihood of repeating identical phrases is reduced.     The default setting for this penalty is zero.";
    };
    PRESENCE_PENALTY: {
        readonly type: "range";
        readonly title: "Presence penalty";
        readonly description: "Enhance the introduction of novel subjects by reducing the preference for tokens that have already appeared in the text,     thus boosting the chances of exploring fresh topics.     The standard setting for this is zero.";
    };
    REPETITION_PENALTY: {
        readonly type: "range";
        readonly title: "Repetition penalty";
        readonly description: "Reduces the likelihood of repeating tokens from the input.     Increasing this value makes the model less prone to repetition, but setting it too high may lead to less coherent output,     often resulting in run-on sentences missing smaller words.     The token penalty is scaled according to the original token's probability.";
    };
    SEED: {
        readonly type: "range";
        readonly title: "Seed";
        readonly description: "When seed is fixed to a specific value, the model makes a best effort to provide the same response for repeated requests.     Deterministic output isn't guaranteed.     Also, changing the model or parameter settings, such as the temperature,     can cause variations in the response even when you use the same seed value.     By default, a random seed value is used.";
    };
    LOG_PROBS: {
        readonly type: "boolean";
        readonly title: "Log probs";
        readonly description: "Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned.";
    };
    TOP_LOG_PROBS: {
        readonly type: "range";
        readonly title: "Top log probs";
        readonly description: "The number of most likely tokens to return at each token position, each with an associated log probability.     'logprobs' must be set to true if this parameter is used.";
    };
    ECHO: {
        readonly type: "boolean";
        readonly title: "Echo";
        readonly description: "If true, the response will contain the prompt.";
    };
    RESPONSE_FORMAT: {
        readonly type: "select";
        readonly title: "Response format";
        readonly description: "Choose the response format of your model. For JSON, you must include the string 'JSON' in some form within your system / user prompt.";
    };
    RESPONSE_FORMAT_WITH_SCHEMA: {
        readonly type: "select";
        readonly title: "Response format";
        readonly description: "Choose the response format of your model. 'json_object' colloquially known as JSON mode, instructs the model to respond with a valid   JSON (must include the term 'json' in prompt). 'json_schema' colloquially known as structured outputs, allows you to specify a strict   response schema that the model will adhere to.";
    };
    RESPONSE_SCHEMA: {
        readonly type: "object";
        readonly title: "Response schema";
        readonly description: "When response format is set to 'json_schema', the model will return a JSON object of the specified schema.";
    };
    MAX_REASONING_TOKENS: {
        readonly type: "range";
        readonly title: "Max reasoning tokens";
        readonly description: "Specify the total tokens for reasoning, where one token approximates four English characters.";
    };
};

declare const EMBEDDING_CONFIG: {
    DIMENSIONS: {
        readonly type: "range";
        readonly title: "Dimensions";
        readonly description: "Select the number of dimensions for the word embedding.";
    };
    ENCODING_FORMAT: {
        readonly type: "select";
        readonly title: "Encoding format";
        readonly description: "Select the encoding format for the word embedding.";
    };
};

declare const getErrorMessage: (error: unknown | undefined) => string;

declare const removeUndefinedEntries: <T = unknown>(record: Record<string, T | undefined>) => Record<string, T>;

declare const convertBase64ToUint8Array: (base64String: string) => Uint8Array;
declare const convertUint8ArrayToBase64: (array: Uint8Array) => string;
declare const encodedBase64ToString: (base64: string) => string;
declare const getMimeTypeFromBase64: (base64: string) => string;

declare const urlWithoutTrailingSlash: (url: string) => string;

declare const isRunningInBrowser: () => boolean;

export { CHAT_CONFIG, ChatModelSchema, type ChatModelSchemaType, type ChatModelV1, ConfigItemDef, type ConfigItemDefType, ConfigItemEnum, type ConfigItemEnumType, ConfigItemLiterals, EMBEDDING_CONFIG, EmbeddingModelSchema, type EmbeddingModelSchemaType, type EmbeddingModelV1, Headers, type HeadersType, InvalidConfigError, InvalidEmbeddingRequestsError, InvalidMessagesError, InvalidModelRequestError, InvalidToolsError, ModelError, ModelResponseError, MultiStringConfigItem, MultiStringConfigItemDef, MultiStringConfigItemSchema, type MultiStringConfigItemSchemaType, type MultiStringConfigItemType, MultiStringConfigItemTypeLiteral, ObjectSchemaConfigItem, ObjectSchemaConfigItemDef, ObjectSchemaConfigItemSchema, type ObjectSchemaConfigItemSchemaType, type ObjectSchemaConfigItemType, ObjectSchemaConfigItemTypeLiteral, Params, type ParamsType, ProviderError, type ProviderV1, RangeConfigItem, RangeConfigItemDef, type RangeConfigItemDefType, RangeConfigItemSchema, type RangeConfigItemSchemaType, RangeConfigItemTypeLiteral, SelectBooleanConfigItem, SelectBooleanConfigItemDef, type SelectBooleanConfigItemDefType, SelectBooleanConfigItemSchema, type SelectBooleanConfigItemSchemaType, SelectBooleanConfigItemTypeLiteral, SelectStringConfigItem, SelectStringConfigItemDef, type SelectStringConfigItemDefType, SelectStringConfigItemSchema, type SelectStringConfigItemSchemaType, SelectStringConfigItemTypeLiteral, Url, type UrlType, convertBase64ToUint8Array, convertUint8ArrayToBase64, encodedBase64ToString, getErrorMessage, getMimeTypeFromBase64, isRunningInBrowser, removeUndefinedEntries, urlWithoutTrailingSlash };