import { GatewayBaseError, RoleEnum, ModalityEnum, MessageType, ConfigType, ToolType, ChatResponseType, PartialChatResponseType, ChatModelPriceType, EmbeddingModalityEnum, EmbeddingRequestsType, EmbeddingResponseType, EmbeddingModelPriceType } 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", "pdf", "tool-call", "tool-response", "reasoning", "error", "search-result"]>>(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;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"paired-select">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            fields: z.ZodTuple<[z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>, z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>], null>;
            uniqueByField: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodOptional<z.ZodString>;
            minLength: z.ZodOptional<z.ZodNumber>;
            maxLength: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>]>>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"paired-select">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            fields: z.ZodTuple<[z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>, z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>], null>;
            uniqueByField: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodOptional<z.ZodString>;
            minLength: z.ZodOptional<z.ZodNumber>;
            maxLength: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>]>>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"paired-select">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            fields: z.ZodTuple<[z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>, z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>], null>;
            uniqueByField: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodOptional<z.ZodString>;
            minLength: z.ZodOptional<z.ZodNumber>;
            maxLength: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>]>>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"paired-select">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            fields: z.ZodTuple<[z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>, z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>], null>;
            uniqueByField: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodOptional<z.ZodString>;
            minLength: z.ZodOptional<z.ZodNumber>;
            maxLength: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>]>>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"paired-select">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            fields: z.ZodTuple<[z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>, z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>], null>;
            uniqueByField: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodOptional<z.ZodString>;
            minLength: z.ZodOptional<z.ZodNumber>;
            maxLength: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>]>>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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", "paired-select", "string"];
declare const ConfigItemEnum: z.ZodEnum<["range", "multi-string", "select-string", "object-schema", "select-boolean", "paired-select", "string"]>;
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;
}>, z.ZodObject<{
    type: z.ZodLiteral<"paired-select">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    fields: z.ZodTuple<[z.ZodObject<{
        key: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        choices: z.ZodArray<z.ZodObject<{
            value: z.ZodString;
            label: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: string;
            label: string;
        }, {
            value: string;
            label: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }>, z.ZodObject<{
        key: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        choices: z.ZodArray<z.ZodObject<{
            value: z.ZodString;
            label: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: string;
            label: string;
        }, {
            value: string;
            label: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }>], null>;
    uniqueByField: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: "paired-select";
    param: string;
    title: string;
    description: string;
    fields: [{
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }];
    uniqueByField?: string | undefined;
}, {
    type: "paired-select";
    param: string;
    title: string;
    description: string;
    fields: [{
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }];
    uniqueByField?: string | undefined;
}>, z.ZodObject<{
    type: z.ZodLiteral<"string">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    default: z.ZodOptional<z.ZodString>;
    minLength: z.ZodOptional<z.ZodNumber>;
    maxLength: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "string";
    param: string;
    title: string;
    description: string;
    default?: string | undefined;
    minLength?: number | undefined;
    maxLength?: number | undefined;
}, {
    type: "string";
    param: string;
    title: string;
    description: string;
    default?: string | undefined;
    minLength?: number | undefined;
    maxLength?: number | undefined;
}>]>;
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 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;
    }>>;
};

declare const PairedSelectConfigItemTypeLiteral: "paired-select";
declare const PairedSelectChoice: z.ZodObject<{
    value: z.ZodString;
    label: z.ZodString;
}, "strip", z.ZodTypeAny, {
    value: string;
    label: string;
}, {
    value: string;
    label: string;
}>;
type PairedSelectChoiceType = z.infer<typeof PairedSelectChoice>;
declare const PairedSelectFieldDef: z.ZodObject<{
    key: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    choices: z.ZodArray<z.ZodObject<{
        value: z.ZodString;
        label: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: string;
        label: string;
    }, {
        value: string;
        label: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    label: string;
    key: string;
    choices: {
        value: string;
        label: string;
    }[];
    description?: string | undefined;
}, {
    label: string;
    key: string;
    choices: {
        value: string;
        label: string;
    }[];
    description?: string | undefined;
}>;
type PairedSelectFieldDefType = z.infer<typeof PairedSelectFieldDef>;
declare const PairedSelectConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"paired-select">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    fields: z.ZodTuple<[z.ZodObject<{
        key: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        choices: z.ZodArray<z.ZodObject<{
            value: z.ZodString;
            label: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: string;
            label: string;
        }, {
            value: string;
            label: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }>, z.ZodObject<{
        key: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        choices: z.ZodArray<z.ZodObject<{
            value: z.ZodString;
            label: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: string;
            label: string;
        }, {
            value: string;
            label: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }>], null>;
    uniqueByField: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: "paired-select";
    param: string;
    title: string;
    description: string;
    fields: [{
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }];
    uniqueByField?: string | undefined;
}, {
    type: "paired-select";
    param: string;
    title: string;
    description: string;
    fields: [{
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }, {
        label: string;
        key: string;
        choices: {
            value: string;
            label: string;
        }[];
        description?: string | undefined;
    }];
    uniqueByField?: string | undefined;
}>;
type PairedSelectConfigItemType = z.infer<typeof PairedSelectConfigItemDef>;
declare const PairedSelectConfigItemSchema: (fields: readonly [PairedSelectFieldDefType, PairedSelectFieldDefType]) => z.ZodOptional<z.ZodArray<z.ZodObject<z.ZodRawShape, "strip", z.ZodTypeAny, {
    [x: string]: any;
}, {
    [x: string]: any;
}>, "many">>;
type PairedSelectConfigItemSchemaType = z.infer<ReturnType<typeof PairedSelectConfigItemSchema>>;
declare const PairedSelectConfigItem: (data: Omit<PairedSelectConfigItemType, "type">) => {
    def: {
        type: "paired-select";
        param: string;
        title: string;
        description: string;
        fields: [{
            label: string;
            key: string;
            choices: {
                value: string;
                label: string;
            }[];
            description?: string | undefined;
        }, {
            label: string;
            key: string;
            choices: {
                value: string;
                label: string;
            }[];
            description?: string | undefined;
        }];
        uniqueByField?: string | undefined;
    };
    schema: z.ZodOptional<z.ZodArray<z.ZodObject<z.ZodRawShape, "strip", z.ZodTypeAny, {
        [x: string]: any;
    }, {
        [x: string]: any;
    }>, "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 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 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 StringConfigItemTypeLiteral: "string";
declare const StringConfigItemDef: z.ZodObject<{
    type: z.ZodLiteral<"string">;
    param: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    default: z.ZodOptional<z.ZodString>;
    minLength: z.ZodOptional<z.ZodNumber>;
    maxLength: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    type: "string";
    param: string;
    title: string;
    description: string;
    default?: string | undefined;
    minLength?: number | undefined;
    maxLength?: number | undefined;
}, {
    type: "string";
    param: string;
    title: string;
    description: string;
    default?: string | undefined;
    minLength?: number | undefined;
    maxLength?: number | undefined;
}>;
type StringConfigItemDefType = z.infer<typeof StringConfigItemDef>;
declare const StringConfigItemSchema: (defaultValue?: string, minLength?: number, maxLength?: number) => z.ZodOptional<z.ZodString> | z.ZodOptional<z.ZodDefault<z.ZodString>>;
type StringConfigItemSchemaType = z.infer<ReturnType<typeof StringConfigItemSchema>>;
declare const StringConfigItem: (data: Omit<StringConfigItemDefType, "type">) => {
    def: {
        type: "string";
        param: string;
        title: string;
        description: string;
        default?: string | undefined;
        minLength?: number | undefined;
        maxLength?: number | undefined;
    };
    schema: z.ZodOptional<z.ZodString> | z.ZodOptional<z.ZodDefault<z.ZodString>>;
};

interface ChatModelV1<MS extends ChatModelSchemaType = ChatModelSchemaType> {
    readonly version: "v1";
    readonly modelSchema: MS;
    getDefaultBaseUrl(): UrlType;
    getDefaultHeaders(): HeadersType;
    getDefaultParams(): ParamsType;
    getRetryDelay(responseHeaders: HeadersType, responseData: unknown): {
        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[], config?: ConfigType, tools?: ToolType[]): ParamsType;
    transformTools(tools: ToolType[], config?: ConfigType, messages?: MessageType[]): 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;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"paired-select">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            fields: z.ZodTuple<[z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>, z.ZodObject<{
                key: z.ZodString;
                label: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
                choices: z.ZodArray<z.ZodObject<{
                    value: z.ZodString;
                    label: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: string;
                    label: string;
                }, {
                    value: string;
                    label: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }>], null>;
            uniqueByField: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }, {
            type: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        }>, z.ZodObject<{
            type: z.ZodLiteral<"string">;
            param: z.ZodString;
            title: z.ZodString;
            description: z.ZodString;
            default: z.ZodOptional<z.ZodString>;
            minLength: z.ZodOptional<z.ZodNumber>;
            maxLength: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }, {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>]>>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    }>;
    price: z.ZodType<{
        inputPricePerMillion: number;
        modelName: string;
        currency: string;
    }, z.ZodTypeDef, {
        inputPricePerMillion: number;
        modelName: string;
        currency: string;
    }>;
}, "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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        inputPricePerMillion: number;
        modelName: string;
        currency: string;
    };
}, {
    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: "paired-select";
            param: string;
            title: string;
            description: string;
            fields: [{
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }, {
                label: string;
                key: string;
                choices: {
                    value: string;
                    label: string;
                }[];
                description?: string | undefined;
            }];
            uniqueByField?: string | undefined;
        } | {
            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[];
        } | {
            type: "string";
            param: string;
            title: string;
            description: string;
            default?: string | undefined;
            minLength?: number | undefined;
            maxLength?: number | undefined;
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        inputPricePerMillion: number;
        modelName: string;
        currency: string;
    };
}>;
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, responseData: unknown): {
        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;
    getModelPricing(): EmbeddingModelPriceType;
}

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.";
    };
    MCP_SERVERS: {
        readonly type: "object";
        readonly title: "MCP servers";
        readonly description: "MCP servers to use for the model.";
    };
};

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, PairedSelectChoice, type PairedSelectChoiceType, PairedSelectConfigItem, PairedSelectConfigItemDef, PairedSelectConfigItemSchema, type PairedSelectConfigItemSchemaType, type PairedSelectConfigItemType, PairedSelectConfigItemTypeLiteral, PairedSelectFieldDef, type PairedSelectFieldDefType, 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, StringConfigItem, StringConfigItemDef, type StringConfigItemDefType, StringConfigItemSchema, type StringConfigItemSchemaType, StringConfigItemTypeLiteral, Url, type UrlType, convertBase64ToUint8Array, convertUint8ArrayToBase64, encodedBase64ToString, getErrorMessage, getMimeTypeFromBase64, isRunningInBrowser, removeUndefinedEntries, urlWithoutTrailingSlash };
