@adaline/azure/dist/index.d.mts

Adaline Azure

import { ChatModelSchemaType, HeadersType, EmbeddingModelSchemaType, ProviderV1, ChatModelV1, EmbeddingModelV1 } from '@adaline/provider';
import * as zod from 'zod';
import { z } from 'zod';
import { BaseChatModel, BaseEmbeddingModel } from '@adaline/openai';
import { ChatModelPriceType } from '@adaline/types';

declare const BaseChatModelOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type BaseChatModelOptionsType = z.infer<typeof BaseChatModelOptions>;

declare const BaseChatModelSchema: {
    name: string;
    description: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};

declare class BaseChatModelOpenAI extends BaseChatModel {
    readonly version: "v1";
    modelSchema: ChatModelSchemaType;
    readonly deploymentId: string;
    private readonly azureApiKey;
    private readonly azureApiVersion;
    constructor(modelSchema: ChatModelSchemaType, options: BaseChatModelOptionsType);
    getDefaultHeaders(): HeadersType;
    getModelPricing(): ChatModelPriceType;
}

declare const GPT_4oLiteral: "gpt-4o";
declare const GPT_4oSchema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4oOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4oOptionsType = z.infer<typeof GPT_4oOptions>;
declare class GPT_4o extends BaseChatModelOpenAI {
    constructor(options: GPT_4oOptionsType);
}

declare const GPT_4o_MiniLiteral: "gpt-4o-mini";
declare const GPT_4o_MiniSchema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4o_MiniOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4o_MiniOptionsType = z.infer<typeof GPT_4o_MiniOptions>;
declare class GPT_4o_Mini extends BaseChatModelOpenAI {
    constructor(options: GPT_4o_MiniOptionsType);
}

declare const GPT_4o_Mini_2024_07_18Literal: "gpt-4o-mini-2024-07-18";
declare const GPT_4o_Mini_2024_07_18Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4o_Mini_2024_07_18Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4o_Mini_2024_07_18OptionsType = z.infer<typeof GPT_4o_Mini_2024_07_18Options>;
declare class GPT_4o_Mini_2024_07_18 extends BaseChatModelOpenAI {
    constructor(options: GPT_4o_Mini_2024_07_18OptionsType);
}

declare const GPT_4o_2024_08_06Literal: "gpt-4o-2024-08-06";
declare const GPT_4o_2024_08_06Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4o_2024_08_06Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4o_2024_08_06OptionsType = z.infer<typeof GPT_4o_2024_08_06Options>;
declare class GPT_4o_2024_08_06 extends BaseChatModelOpenAI {
    constructor(options: GPT_4o_2024_08_06OptionsType);
}

declare const GPT_4o_2024_05_13Literal: "gpt-4o-2024-05-13";
declare const GPT_4o_2024_05_13Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4o_2024_05_13Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4o_2024_05_13OptionsType = z.infer<typeof GPT_4o_2024_05_13Options>;
declare class GPT_4o_2024_05_13 extends BaseChatModelOpenAI {
    constructor(options: GPT_4o_2024_05_13OptionsType);
}

declare const GPT_4Literal: "gpt-4";
declare const GPT_4Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4OptionsType = z.infer<typeof GPT_4Options>;
declare class GPT_4 extends BaseChatModelOpenAI {
    constructor(options: GPT_4OptionsType);
}

declare const GPT_4_Turbo_2024_04_09Literal: "gpt-4-turbo-2024-04-09";
declare const GPT_4_Turbo_2024_04_09Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "image" | "tool-call" | "tool-response", ...("text" | "image" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4_Turbo_2024_04_09Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4_Turbo_2024_04_09OptionsType = z.infer<typeof GPT_4_Turbo_2024_04_09Options>;
declare class GPT_4_Turbo_2024_04_09 extends BaseChatModelOpenAI {
    constructor(options: GPT_4_Turbo_2024_04_09OptionsType);
}

declare const GPT_4_1106_PreviewLiteral: "gpt-4-1106-preview";
declare const GPT_4_1106_PreviewSchema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4_1106_PreviewOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4_1106_PreviewOptionsType = z.infer<typeof GPT_4_1106_PreviewOptions>;
declare class GPT_4_1106_Preview extends BaseChatModelOpenAI {
    constructor(options: GPT_4_1106_PreviewOptionsType);
}

declare const GPT_4_0613Literal: "gpt-4-0613";
declare const GPT_4_0613Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_4_0613Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_4_0613OptionsType = z.infer<typeof GPT_4_0613Options>;
declare class GPT_4_0613 extends BaseChatModelOpenAI {
    constructor(options: GPT_4_0613OptionsType);
}

declare const GPT_3_5_TurboLiteral: "gpt-3-5-turbo";
declare const GPT_3_5_TurboSchema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_3_5_TurboOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_3_5_TurboOptionsType = z.infer<typeof GPT_3_5_TurboOptions>;
declare class GPT_3_5_Turbo extends BaseChatModelOpenAI {
    constructor(options: GPT_3_5_TurboOptionsType);
}

declare const GPT_3_5_Turbo_1106Literal: "gpt-3-5-turbo-1106";
declare const GPT_3_5_Turbo_1106Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_3_5_Turbo_1106Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_3_5_Turbo_1106OptionsType = z.infer<typeof GPT_3_5_Turbo_1106Options>;
declare class GPT_3_5_Turbo_1106 extends BaseChatModelOpenAI {
    constructor(options: GPT_3_5_Turbo_1106OptionsType);
}

declare const GPT_3_5_Turbo_0125Literal: "gpt-3-5-turbo-0125";
declare const GPT_3_5_Turbo_0125Schema: {
    description: string;
    name: string;
    roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
    modalities: ["text" | "tool-call" | "tool-response", ...("text" | "tool-call" | "tool-response")[]];
    maxInputTokens: number;
    maxOutputTokens: number;
    config: {
        def: Record<string, {
            type: "multi-string";
            param: string;
            title: string;
            description: string;
            max: number;
        } | {
            type: "object-schema";
            param: string;
            title: string;
            description: string;
            objectSchema?: any;
        } | {
            type: "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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
    price: {
        modelName: string;
        currency: string;
        tokenRanges: {
            minTokens: number;
            prices: {
                base: {
                    inputPricePerMillion: number;
                    outputPricePerMillion: number;
                };
            };
            maxTokens?: number | null | undefined;
        }[];
    };
    maxReasoningTokens?: number | undefined;
};
declare const GPT_3_5_Turbo_0125Options: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type GPT_3_5_Turbo_0125OptionsType = z.infer<typeof GPT_3_5_Turbo_0125Options>;
declare class GPT_3_5_Turbo_0125 extends BaseChatModelOpenAI {
    constructor(options: GPT_3_5_Turbo_0125OptionsType);
}

declare const BaseEmbeddingModelOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type BaseEmbeddingModelOptionsType = z.infer<typeof BaseEmbeddingModelOptions>;

declare const BaseEmbeddingModelSchema: {
    description: string;
    name: string;
    modalities: ["text" | "token", ...("text" | "token")[]];
    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[];
        }>;
        schema: zod.ZodObject<zod.ZodRawShape, zod.UnknownKeysParam, zod.ZodTypeAny, unknown, unknown>;
    };
};

declare class BaseEmbeddingModelOpenAI extends BaseEmbeddingModel {
    readonly version: "v1";
    modelSchema: EmbeddingModelSchemaType;
    readonly deploymentId: string;
    private readonly azureApiKey;
    private readonly azureApiVersion;
    constructor(modelSchema: EmbeddingModelSchemaType, options: BaseEmbeddingModelOptionsType);
    getDefaultHeaders(): HeadersType;
}

declare const Text_Embedding_3_LargeLiteral: "text-embedding-3-large";
declare const Text_Embedding_3_LargeSchema: {
    description: string;
    name: string;
    modalities: ["text" | "token", ...("text" | "token")[]];
    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[];
        }>;
        schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
    };
};
declare const Text_Embedding_3_LargeOptions: z.ZodObject<{
    apiKey: z.ZodString;
    deploymentId: z.ZodString;
    resourceName: z.ZodOptional<z.ZodString>;
    baseUrl: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}, {
    apiKey: string;
    deploymentId: string;
    resourceName?: string | undefined;
    baseUrl?: string | undefined;
}>;
type Text_Embedding_3_LargeOptionsType = z.infer<typeof Text_Embedding_3_LargeOptions>;
declare class Text_Embedding_3_Large extends BaseEmbeddingModelOpenAI {
    constructor(options: Text_Embedding_3_LargeOptionsType);
}

declare const Text_Embedding_Ada_002Literal: "text-embedding-ada-002";
declare const Text_Embedding_Ada_002Schema: {
    description: string;
    name: string;
    modalities: ["text" | "token", ...("text" | "token")[]];
    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;