import { GatewayBaseError } from '@adaline/types';
import { Context, Tracer, Meter } from '@opentelemetry/api';
import { z } from 'zod';
import { ChatModelV1, EmbeddingModelV1 } from '@adaline/provider';
import { AxiosInstance } from 'axios';

declare class GatewayError extends Error {
    status: number;
    data: unknown;
    constructor(message: string, status?: number, data?: unknown);
}
declare class GatewayTelemetryError extends GatewayBaseError {
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isGatewayTelemetryError(error: unknown): error is GatewayTelemetryError;
}

interface HttpClient {
    stream<T>(url: string, method: "get" | "post", data?: Record<string, unknown>, headers?: Record<string, string>, options?: {
        abortSignal?: AbortSignal;
    }, telemetryContext?: Context): AsyncGenerator<T, void, unknown>;
    get<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    post<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    put<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    delete<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    patch<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
}
interface HttpClientResponse<T> {
    data: T;
    headers: Record<string, string>;
    status: {
        code: number;
        text: string;
    };
}

declare class HttpClientError extends GatewayBaseError {
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isHttpClientError(error: unknown): error is HttpClientError;
}
declare class HttpRequestError extends GatewayBaseError {
    readonly info: string;
    readonly cause: {
        status: number;
        headers: Record<string, string>;
        data: unknown;
    };
    constructor(message: string, status: number | undefined, headers: Record<string, string>, data: unknown);
    static isHttpRequestError(error: unknown): error is HttpRequestError;
}

interface IsomorphicHttpClientConfig {
    timeoutInMilliseconds?: number;
    axiosInstance?: AxiosInstance;
    telemetryTracer?: Tracer;
    enableProxyAgent?: boolean;
}
declare class IsomorphicHttpClient implements HttpClient {
    private defaultTimeout?;
    private client;
    private httpProxyAgent?;
    private httpsProxyAgent?;
    private enableProxyAgent;
    constructor(config: IsomorphicHttpClientConfig);
    isNodeEnvironment: () => boolean;
    private makeRequest;
    stream<T>(url: string, method: "get" | "post", data?: Record<string, unknown>, headers?: Record<string, string>, options?: {
        abortSignal?: AbortSignal;
    }, telemetryContext?: Context): AsyncGenerator<T, void, unknown>;
    get<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    post<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    put<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    delete<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    patch<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
}

declare class QueueTaskTimeoutError extends GatewayBaseError {
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isQueueTaskTimeoutError(error: unknown): error is QueueTaskTimeoutError;
}

interface Cache<T> {
    get(key: string): Promise<T | undefined>;
    set(key: string, value: T): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
}

declare class LRUCache<T extends object> implements Cache<T> {
    private cache;
    constructor(maxEntries?: number);
    get(key: string): Promise<T | undefined>;
    set(key: string, value: T): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
}

type QueueTask<Request, Response> = {
    id: string;
    request: Request;
    cache?: Cache<Response>;
    resolve: (value: Response) => void;
    reject: (error: any) => void;
    execute: (request: Request, context: Context) => Promise<Response>;
    telemetryContext: Context;
};
interface Queue<Request, Response> {
    enqueue(task: QueueTask<Request, Response>): void;
}
declare const QueueOptions: z.ZodObject<{
    maxConcurrentTasks: z.ZodNumber;
    retryCount: z.ZodNumber;
    timeout: z.ZodNumber;
    retry: z.ZodObject<{
        initialDelay: z.ZodNumber;
        exponentialFactor: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        initialDelay: number;
        exponentialFactor: number;
    }, {
        initialDelay: number;
        exponentialFactor: number;
    }>;
}, "strip", z.ZodTypeAny, {
    timeout: number;
    maxConcurrentTasks: number;
    retryCount: number;
    retry: {
        initialDelay: number;
        exponentialFactor: number;
    };
}, {
    timeout: number;
    maxConcurrentTasks: number;
    retryCount: number;
    retry: {
        initialDelay: number;
        exponentialFactor: number;
    };
}>;
type QueueOptionsType = z.infer<typeof QueueOptions>;

declare class SimpleQueue<Request, Response> implements Queue<Request, Response> {
    private options;
    private activeTasks;
    private queue;
    constructor(options: QueueOptionsType);
    enqueue(task: QueueTask<Request, Response>): void;
    private executeWithTimeout;
    private executeWithRetry;
    private processQueue;
}

type AnalyticsNodeEnvironment = {
    node: {
        version: string;
        platform: string;
        architecture: string;
    };
};
type AnalyticsBrowserEnvironment = {
    browser: {
        version: string;
        userAgent: string;
    };
};
type AnalyticsEvent = {
    event: string;
    timestamp: string;
    dimensions: {
        [key: string]: any;
    };
    status: string;
    eventVersion: string;
    gatewayVersion: string;
    environment: AnalyticsNodeEnvironment | AnalyticsBrowserEnvironment;
    userId?: string;
};
interface AnalyticsRecorder {
    record(event: AnalyticsEvent["event"], status: AnalyticsEvent["status"], dimensions: AnalyticsEvent["dimensions"]): void;
    stopRecorder(): void;
}

declare class AnalyticsManager {
    private static analytics;
    static getAnalyticsRecorder(analyticsEnabled: boolean): AnalyticsRecorder;
}

declare class PostAnalytics implements AnalyticsRecorder {
    private readonly eventVersion;
    private readonly gatewayVersion;
    private flushTimer;
    private flushInterval;
    private batchSize;
    private maxAttempts;
    private environment;
    private analyticsEndpointUrl;
    private events;
    constructor();
    private startFlushTimer;
    private stopFlushTimer;
    record(event: AnalyticsEvent["event"], status: AnalyticsEvent["status"], dimensions: AnalyticsEvent["dimensions"]): void;
    private flushEvents;
    private sendEvents;
    stopRecorder(): void;
}

declare class NoOpAnalytics implements AnalyticsRecorder {
    record(event: AnalyticsEvent["event"], status: AnalyticsEvent["status"], dimensions: AnalyticsEvent["dimensions"]): void;
    stopRecorder(): void;
}

declare class TelemetryManager {
    static DEFAULT_TRACER_KEY: string;
    static DEFAULT_METER_KEY: string;
    private static tracer;
    private static meter;
    static setTracer(tracer: Tracer | undefined): void;
    static getTracer(): Tracer;
    static setMeter(meter: Meter | undefined): void;
    static getMeter(): Meter;
}

interface Logger {
    debug(message: string, ...params: any[]): void;
    info(message: string, ...params: any[]): void;
    warn(message: string, ...params: any[]): void;
    error(message: string, ...params: any[]): void;
    critical(message: string, ...params: any[]): void;
}

declare class LoggerManager {
    private static logger;
    static setLogger(logger: Logger | undefined): void;
    static getLogger(): Logger | undefined;
}

declare class ConsoleLogger implements Logger {
    debug(message: string, ...params: any[]): void;
    info(message: string, ...params: any[]): void;
    warn(message: string, ...params: any[]): void;
    error(message: string, ...params: any[]): void;
    critical(message: string, ...params: any[]): void;
}

declare const CompleteChatHandlerRequest: z.ZodObject<{
    cache: z.ZodType<Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>, z.ZodTypeDef, Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>>;
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    messages: z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
        content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
            modality: z.ZodLiteral<"text">;
            value: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"image">;
            detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                base64: z.ZodString;
                media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "url";
                url: string;
            }, {
                type: "url";
                url: string;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-call">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            arguments: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-response">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            data: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }>]>, "many">;
        metadata: z.ZodUndefined;
    }, "strip", z.ZodTypeAny, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }>, "many">;
    tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
        type: z.ZodEnum<["function"]>;
        definition: z.ZodObject<{
            schema: z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                parameters: z.ZodAny;
                strict: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }>;
        }, "strip", z.ZodTypeAny, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }>;
    }, {
        metadata: z.ZodTypeAny;
    }>, "strip", z.ZodTypeAny, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }>]>, "many">>;
    enableCache: z.ZodBoolean;
    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    callbacks: z.ZodOptional<z.ZodArray<z.ZodType<CompleteChatCallbackType<any>, z.ZodTypeDef, CompleteChatCallbackType<any>>, "atleastone">>;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    enableCache: boolean;
    cache: Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>;
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
    customHeaders?: Record<string, string> | undefined;
    metadataForCallbacks?: any;
    callbacks?: [CompleteChatCallbackType<any>, ...CompleteChatCallbackType<any>[]] | undefined;
}, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    enableCache: boolean;
    cache: Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>;
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
    customHeaders?: Record<string, string> | undefined;
    metadataForCallbacks?: any;
    callbacks?: [CompleteChatCallbackType<any>, ...CompleteChatCallbackType<any>[]] | undefined;
}>;
type CompleteChatHandlerRequestType = z.infer<typeof CompleteChatHandlerRequest>;
declare const CompleteChatHandlerResponse: z.ZodObject<{
    request: z.ZodObject<{
        config: z.ZodRecord<z.ZodString, z.ZodAny>;
        messages: z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
            content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
                modality: z.ZodLiteral<"text">;
                value: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"image">;
                detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
                value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                    type: z.ZodLiteral<"base64">;
                    base64: z.ZodString;
                    media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
                }, "strip", z.ZodTypeAny, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }>, z.ZodObject<{
                    type: z.ZodLiteral<"url">;
                    url: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "url";
                    url: string;
                }, {
                    type: "url";
                    url: string;
                }>]>;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-call">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                arguments: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            }, {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-response">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                data: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            }, {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            }>]>, "many">;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }>, "many">;
        tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
            type: z.ZodEnum<["function"]>;
            definition: z.ZodObject<{
                schema: z.ZodObject<{
                    name: z.ZodString;
                    description: z.ZodString;
                    parameters: z.ZodAny;
                    strict: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                }, {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                }>;
            }, "strip", z.ZodTypeAny, {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            }, {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            }>;
        }, {
            metadata: z.ZodTypeAny;
        }>, "strip", z.ZodTypeAny, {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }, {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }>]>, "many">>;
    }, "strip", z.ZodTypeAny, {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    }, {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    }>;
    response: z.ZodObject<{
        messages: z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
            content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
                modality: z.ZodLiteral<"text">;
                value: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"image">;
                detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
                value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                    type: z.ZodLiteral<"base64">;
                    base64: z.ZodString;
                    media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
                }, "strip", z.ZodTypeAny, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }>, z.ZodObject<{
                    type: z.ZodLiteral<"url">;
                    url: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "url";
                    url: string;
                }, {
                    type: "url";
                    url: string;
                }>]>;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-call">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                arguments: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            }, {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-response">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                data: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            }, {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            }>]>, "many">;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            promptTokens: z.ZodNumber;
            completionTokens: z.ZodNumber;
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }>>;
        logProbs: z.ZodOptional<z.ZodArray<z.ZodObject<z.objectUtil.extendShape<{
            token: z.ZodString;
            logProb: z.ZodNumber;
            bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
        }, {
            topLogProbs: z.ZodArray<z.ZodObject<{
                token: z.ZodString;
                logProb: z.ZodNumber;
                bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
            }, "strip", z.ZodTypeAny, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }>, "many">;
        }>, "strip", z.ZodTypeAny, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }, {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }>;
    cached: z.ZodBoolean;
    latencyInMs: z.ZodNumber;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    provider: z.ZodObject<{
        request: z.ZodAny;
        response: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        request?: any;
        response?: any;
    }, {
        request?: any;
        response?: any;
    }>;
}, "strip", z.ZodTypeAny, {
    request: {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    };
    response: {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    };
    cached: boolean;
    latencyInMs: number;
    provider: {
        request?: any;
        response?: any;
    };
    metadataForCallbacks?: any;
}, {
    request: {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    };
    response: {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    };
    cached: boolean;
    latencyInMs: number;
    provider: {
        request?: any;
        response?: any;
    };
    metadataForCallbacks?: any;
}>;
type CompleteChatHandlerResponseType = z.infer<typeof CompleteChatHandlerResponse>;
type CompleteChatCallbackType<M = any> = {
    onChatStart?: (metadata?: M) => Promise<void> | void;
    onChatCached?: (metadata?: M, response?: CompleteChatHandlerResponseType) => Promise<void> | void;
    onChatComplete?: (metadata?: M, response?: CompleteChatHandlerResponseType) => Promise<void> | void;
    onChatError?: (metadata?: M, error?: GatewayError | HttpRequestError) => Promise<void> | void;
};

declare function handleCompleteChat(request: CompleteChatHandlerRequestType, client: HttpClient, telemetryContext?: Context): Promise<CompleteChatHandlerResponseType>;

declare const GetEmbeddingsHandlerRequest: z.ZodObject<{
    cache: z.ZodType<Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>, z.ZodTypeDef, Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>>;
    model: z.ZodType<EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    embeddingRequests: z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
        modality: z.ZodLiteral<"text">;
        metadata: z.ZodUndefined;
        requests: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    }, {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    }>, z.ZodObject<{
        modality: z.ZodLiteral<"token">;
        metadata: z.ZodUndefined;
        requests: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
    }, "strip", z.ZodTypeAny, {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    }, {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    }>]>;
    enableCache: z.ZodBoolean;
    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    callbacks: z.ZodOptional<z.ZodArray<z.ZodType<GetEmbeddingsCallbackType<any>, z.ZodTypeDef, GetEmbeddingsCallbackType<any>>, "atleastone">>;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    enableCache: boolean;
    cache: Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>;
    embeddingRequests: {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    } | {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    };
    customHeaders?: Record<string, string> | undefined;
    metadataForCallbacks?: any;
    callbacks?: [GetEmbeddingsCallbackType<any>, ...GetEmbeddingsCallbackType<any>[]] | undefined;
}, {
    config: Record<string, any>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    enableCache: boolean;
    cache: Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>;
    embeddingRequests: {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    } | {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    };
    customHeaders?: Record<string, string> | undefined;
    metadataForCallbacks?: any;
    callbacks?: [GetEmbeddingsCallbackType<any>, ...GetEmbeddingsCallbackType<any>[]] | undefined;
}>;
type GetEmbeddingsHandlerRequestType = z.infer<typeof GetEmbeddingsHandlerRequest>;
declare const GetEmbeddingsHandlerResponse: z.ZodObject<{
    request: z.ZodObject<{
        config: z.ZodRecord<z.ZodString, z.ZodAny>;
        embeddingRequests: z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
            modality: z.ZodLiteral<"text">;
            metadata: z.ZodUndefined;
            requests: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            modality: "text";
            requests: string[];
            metadata?: undefined;
        }, {
            modality: "text";
            requests: string[];
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"token">;
            metadata: z.ZodUndefined;
            requests: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
        }, "strip", z.ZodTypeAny, {
            modality: "token";
            requests: number[][];
            metadata?: undefined;
        }, {
            modality: "token";
            requests: number[][];
            metadata?: undefined;
        }>]>;
    }, "strip", z.ZodTypeAny, {
        config: Record<string, any>;
        embeddingRequests: {
            modality: "text";
            requests: string[];
            metadata?: undefined;
        } | {
            modality: "token";
            requests: number[][];
            metadata?: undefined;
        };
    }, {
        config: Record<string, any>;
        embeddingRequests: {
            modality: "text";
            requests: string[];
            metadata?: undefined;
        } | {
            modality: "token";
            requests: number[][];
            metadata?: undefined;
        };
    }>;
    response: z.ZodDiscriminatedUnion<"encodingFormat", [z.ZodObject<{
        encodingFormat: z.ZodLiteral<"float">;
        embeddings: z.ZodArray<z.ZodObject<{
            index: z.ZodNumber;
            embedding: z.ZodArray<z.ZodNumber, "many">;
        }, "strip", z.ZodTypeAny, {
            index: number;
            embedding: number[];
        }, {
            index: number;
            embedding: number[];
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
        }, {
            totalTokens: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }, {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }>, z.ZodObject<{
        encodingFormat: z.ZodLiteral<"base64">;
        embeddings: z.ZodArray<z.ZodObject<{
            index: z.ZodNumber;
            embedding: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            index: number;
            embedding: string;
        }, {
            index: number;
            embedding: string;
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
        }, {
            totalTokens: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }, {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }>]>;
    cached: z.ZodBoolean;
    latencyInMs: z.ZodNumber;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    provider: z.ZodObject<{
        request: z.ZodAny;
        response: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        request?: any;
        response?: any;
    }, {
        request?: any;
        response?: any;
    }>;
}, "strip", z.ZodTypeAny, {
    request: {
        config: Record<string, any>;
        embeddingRequests: {
            modality: "text";
            requests: string[];
            metadata?: undefined;
        } | {
            modality: "token";
            requests: number[][];
            metadata?: undefined;
        };
    };
    response: {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    } | {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    };
    cached: boolean;
    latencyInMs: number;
    provider: {
        request?: any;
        response?: any;
    };
    metadataForCallbacks?: any;
}, {
    request: {
        config: Record<string, any>;
        embeddingRequests: {
            modality: "text";
            requests: string[];
            metadata?: undefined;
        } | {
            modality: "token";
            requests: number[][];
            metadata?: undefined;
        };
    };
    response: {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    } | {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    };
    cached: boolean;
    latencyInMs: number;
    provider: {
        request?: any;
        response?: any;
    };
    metadataForCallbacks?: any;
}>;
type GetEmbeddingsHandlerResponseType = z.infer<typeof GetEmbeddingsHandlerResponse>;
type GetEmbeddingsCallbackType<M = any> = {
    onGetEmbeddingsStart?: (metadata?: M) => Promise<void> | void;
    onGetEmbeddingsCached?: (metadata?: M, response?: GetEmbeddingsHandlerResponseType) => Promise<void> | void;
    onGetEmbeddingsComplete?: (metadata?: M, response?: GetEmbeddingsHandlerResponseType) => Promise<void> | void;
    onGetEmbeddingsError?: (metadata?: M, error?: GatewayError | HttpRequestError) => Promise<void> | void;
};

declare function handleGetEmbeddings(request: GetEmbeddingsHandlerRequestType, client: HttpClient, telemetryContext?: Context): Promise<GetEmbeddingsHandlerResponseType>;

declare const ProxyCompleteChatHandlerRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    data: z.ZodAny;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}>;
type ProxyCompleteChatHandlerRequestType = z.infer<typeof ProxyCompleteChatHandlerRequest>;
declare const ProxyCompleteChatHandlerResponse: z.ZodObject<{
    request: z.ZodAny;
    providerRequest: z.ZodObject<{
        url: z.ZodString;
        headers: z.ZodRecord<z.ZodString, z.ZodString>;
        data: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        headers: Record<string, string>;
        url: string;
        data?: any;
    }, {
        headers: Record<string, string>;
        url: string;
        data?: any;
    }>;
    providerResponse: z.ZodAny;
    transformedResponse: z.ZodOptional<z.ZodObject<{
        messages: z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
            content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
                modality: z.ZodLiteral<"text">;
                value: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"image">;
                detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
                value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                    type: z.ZodLiteral<"base64">;
                    base64: z.ZodString;
                    media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
                }, "strip", z.ZodTypeAny, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }>, z.ZodObject<{
                    type: z.ZodLiteral<"url">;
                    url: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "url";
                    url: string;
                }, {
                    type: "url";
                    url: string;
                }>]>;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-call">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                arguments: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            }, {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-response">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                data: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            }, {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            }>]>, "many">;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            promptTokens: z.ZodNumber;
            completionTokens: z.ZodNumber;
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }>>;
        logProbs: z.ZodOptional<z.ZodArray<z.ZodObject<z.objectUtil.extendShape<{
            token: z.ZodString;
            logProb: z.ZodNumber;
            bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
        }, {
            topLogProbs: z.ZodArray<z.ZodObject<{
                token: z.ZodString;
                logProb: z.ZodNumber;
                bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
            }, "strip", z.ZodTypeAny, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }>, "many">;
        }>, "strip", z.ZodTypeAny, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }, {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    providerRequest: {
        headers: Record<string, string>;
        url: string;
        data?: any;
    };
    request?: any;
    providerResponse?: any;
    transformedResponse?: {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    } | undefined;
}, {
    providerRequest: {
        headers: Record<string, string>;
        url: string;
        data?: any;
    };
    request?: any;
    providerResponse?: any;
    transformedResponse?: {
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-call";
                index: number;
                id: string;
                arguments: string;
                metadata?: undefined;
            } | {
                name: string;
                modality: "tool-response";
                index: number;
                id: string;
                data: string;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    } | undefined;
}>;
type ProxyCompleteChatHandlerResponseType = z.infer<typeof ProxyCompleteChatHandlerResponse>;

declare function handleProxyCompleteChat(request: ProxyCompleteChatHandlerRequestType, client: HttpClient, telemetryContext?: Context): Promise<ProxyCompleteChatHandlerResponseType>;

declare const ProxyGetEmbeddingsHandlerRequest: z.ZodObject<{
    model: z.ZodType<EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    data: z.ZodAny;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    headers: Record<string, string>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}, {
    headers: Record<string, string>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}>;
type ProxyGetEmbeddingsHandlerRequestType = z.infer<typeof ProxyGetEmbeddingsHandlerRequest>;
declare const ProxyGetEmbeddingsHandlerResponse: z.ZodObject<{
    request: z.ZodAny;
    providerRequest: z.ZodObject<{
        url: z.ZodString;
        headers: z.ZodRecord<z.ZodString, z.ZodString>;
        data: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        headers: Record<string, string>;
        url: string;
        data?: any;
    }, {
        headers: Record<string, string>;
        url: string;
        data?: any;
    }>;
    providerResponse: z.ZodAny;
    transformedResponse: z.ZodOptional<z.ZodDiscriminatedUnion<"encodingFormat", [z.ZodObject<{
        encodingFormat: z.ZodLiteral<"float">;
        embeddings: z.ZodArray<z.ZodObject<{
            index: z.ZodNumber;
            embedding: z.ZodArray<z.ZodNumber, "many">;
        }, "strip", z.ZodTypeAny, {
            index: number;
            embedding: number[];
        }, {
            index: number;
            embedding: number[];
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
        }, {
            totalTokens: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }, {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }>, z.ZodObject<{
        encodingFormat: z.ZodLiteral<"base64">;
        embeddings: z.ZodArray<z.ZodObject<{
            index: z.ZodNumber;
            embedding: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            index: number;
            embedding: string;
        }, {
            index: number;
            embedding: string;
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
        }, {
            totalTokens: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }, {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    }>]>>;
}, "strip", z.ZodTypeAny, {
    providerRequest: {
        headers: Record<string, string>;
        url: string;
        data?: any;
    };
    request?: any;
    providerResponse?: any;
    transformedResponse?: {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    } | {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    } | undefined;
}, {
    providerRequest: {
        headers: Record<string, string>;
        url: string;
        data?: any;
    };
    request?: any;
    providerResponse?: any;
    transformedResponse?: {
        encodingFormat: "float";
        embeddings: {
            index: number;
            embedding: number[];
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    } | {
        encodingFormat: "base64";
        embeddings: {
            index: number;
            embedding: string;
        }[];
        usage?: {
            totalTokens: number;
        } | undefined;
    } | undefined;
}>;
type ProxyGetEmbeddingsHandlerResponseType = z.infer<typeof ProxyGetEmbeddingsHandlerResponse>;

declare function handleProxyGetEmbeddings(request: ProxyGetEmbeddingsHandlerRequestType, client: HttpClient, telemetryContext?: Context): Promise<ProxyGetEmbeddingsHandlerResponseType>;

declare const ProxyStreamChatHandlerRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    data: z.ZodAny;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}>;
type ProxyStreamChatHandlerRequestType = z.infer<typeof ProxyStreamChatHandlerRequest>;
declare const ProxyStreamChatHandlerResponse: z.ZodObject<{
    request: z.ZodAny;
    providerRequest: z.ZodObject<{
        url: z.ZodString;
        headers: z.ZodRecord<z.ZodString, z.ZodString>;
        data: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        headers: Record<string, string>;
        url: string;
        data?: any;
    }, {
        headers: Record<string, string>;
        url: string;
        data?: any;
    }>;
    providerResponse: z.ZodAny;
    transformedResponse: z.ZodOptional<z.ZodArray<z.ZodObject<{
        partialMessages: z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<["assistant"]>;
            partialContent: z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
                modality: z.ZodLiteral<"partial-text">;
                value: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            }, {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"partial-tool-call">;
                index: z.ZodNumber;
                id: z.ZodOptional<z.ZodString>;
                name: z.ZodOptional<z.ZodString>;
                arguments: z.ZodOptional<z.ZodString>;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            }, {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }, {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            promptTokens: z.ZodNumber;
            completionTokens: z.ZodNumber;
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }>>;
        logProbs: z.ZodOptional<z.ZodArray<z.ZodObject<z.objectUtil.extendShape<{
            token: z.ZodString;
            logProb: z.ZodNumber;
            bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
        }, {
            topLogProbs: z.ZodArray<z.ZodObject<{
                token: z.ZodString;
                logProb: z.ZodNumber;
                bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
            }, "strip", z.ZodTypeAny, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }>, "many">;
        }>, "strip", z.ZodTypeAny, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }, {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    providerRequest: {
        headers: Record<string, string>;
        url: string;
        data?: any;
    };
    request?: any;
    providerResponse?: any;
    transformedResponse?: {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }[] | undefined;
}, {
    providerRequest: {
        headers: Record<string, string>;
        url: string;
        data?: any;
    };
    request?: any;
    providerResponse?: any;
    transformedResponse?: {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }[] | undefined;
}>;
type ProxyStreamChatHandlerResponseType = z.infer<typeof ProxyStreamChatHandlerResponse>;

declare function handleProxyStreamChat(request: ProxyStreamChatHandlerRequestType, client: HttpClient, telemetryContext?: Context): AsyncGenerator<ProxyStreamChatHandlerResponseType, void, unknown>;

declare const StreamChatHandlerRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    messages: z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
        content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
            modality: z.ZodLiteral<"text">;
            value: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"image">;
            detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                base64: z.ZodString;
                media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "url";
                url: string;
            }, {
                type: "url";
                url: string;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-call">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            arguments: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-response">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            data: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }>]>, "many">;
        metadata: z.ZodUndefined;
    }, "strip", z.ZodTypeAny, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }>, "many">;
    tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
        type: z.ZodEnum<["function"]>;
        definition: z.ZodObject<{
            schema: z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                parameters: z.ZodAny;
                strict: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }>;
        }, "strip", z.ZodTypeAny, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }>;
    }, {
        metadata: z.ZodTypeAny;
    }>, "strip", z.ZodTypeAny, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }>]>, "many">>;
    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    callbacks: z.ZodOptional<z.ZodArray<z.ZodType<StreamChatCallbackType<any>, z.ZodTypeDef, StreamChatCallbackType<any>>, "atleastone">>;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    abortSignal: z.ZodOptional<z.ZodType<AbortSignal, z.ZodTypeDef, AbortSignal>>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
    customHeaders?: Record<string, string> | undefined;
    metadataForCallbacks?: any;
    callbacks?: [StreamChatCallbackType<any>, ...StreamChatCallbackType<any>[]] | undefined;
    abortSignal?: AbortSignal | undefined;
}, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
    customHeaders?: Record<string, string> | undefined;
    metadataForCallbacks?: any;
    callbacks?: [StreamChatCallbackType<any>, ...StreamChatCallbackType<any>[]] | undefined;
    abortSignal?: AbortSignal | undefined;
}>;
type StreamChatHandlerRequestType = z.infer<typeof StreamChatHandlerRequest>;
declare const StreamChatHandlerResponse: z.ZodObject<{
    request: z.ZodObject<{
        config: z.ZodRecord<z.ZodString, z.ZodAny>;
        messages: z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
            content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
                modality: z.ZodLiteral<"text">;
                value: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }, {
                value: string;
                modality: "text";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"image">;
                detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
                value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                    type: z.ZodLiteral<"base64">;
                    base64: z.ZodString;
                    media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
                }, "strip", z.ZodTypeAny, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }, {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                }>, z.ZodObject<{
                    type: z.ZodLiteral<"url">;
                    url: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    type: "url";
                    url: string;
                }, {
                    type: "url";
                    url: string;
                }>]>;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }, {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-call">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                arguments: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            }, {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"tool-response">;
                index: z.ZodNumber;
                id: z.ZodString;
                name: z.ZodString;
                data: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            }, {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            }>]>, "many">;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }, {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }>, "many">;
        tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
            type: z.ZodEnum<["function"]>;
            definition: z.ZodObject<{
                schema: z.ZodObject<{
                    name: z.ZodString;
                    description: z.ZodString;
                    parameters: z.ZodAny;
                    strict: z.ZodOptional<z.ZodBoolean>;
                }, "strip", z.ZodTypeAny, {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                }, {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                }>;
            }, "strip", z.ZodTypeAny, {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            }, {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            }>;
        }, {
            metadata: z.ZodTypeAny;
        }>, "strip", z.ZodTypeAny, {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }, {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }>]>, "many">>;
    }, "strip", z.ZodTypeAny, {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    }, {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    }>;
    response: z.ZodObject<{
        partialMessages: z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<["assistant"]>;
            partialContent: z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
                modality: z.ZodLiteral<"partial-text">;
                value: z.ZodString;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            }, {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            }>, z.ZodObject<{
                modality: z.ZodLiteral<"partial-tool-call">;
                index: z.ZodNumber;
                id: z.ZodOptional<z.ZodString>;
                name: z.ZodOptional<z.ZodString>;
                arguments: z.ZodOptional<z.ZodString>;
                metadata: z.ZodUndefined;
            }, "strip", z.ZodTypeAny, {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            }, {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }, {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }>, "many">;
        usage: z.ZodOptional<z.ZodObject<{
            promptTokens: z.ZodNumber;
            completionTokens: z.ZodNumber;
            totalTokens: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }, {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        }>>;
        logProbs: z.ZodOptional<z.ZodArray<z.ZodObject<z.objectUtil.extendShape<{
            token: z.ZodString;
            logProb: z.ZodNumber;
            bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
        }, {
            topLogProbs: z.ZodArray<z.ZodObject<{
                token: z.ZodString;
                logProb: z.ZodNumber;
                bytes: z.ZodNullable<z.ZodArray<z.ZodNumber, "many">>;
            }, "strip", z.ZodTypeAny, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }, {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }>, "many">;
        }>, "strip", z.ZodTypeAny, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }, {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }, {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    }>;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    provider: z.ZodObject<{
        request: z.ZodAny;
        response: z.ZodAny;
    }, "strip", z.ZodTypeAny, {
        request?: any;
        response?: any;
    }, {
        request?: any;
        response?: any;
    }>;
}, "strip", z.ZodTypeAny, {
    request: {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    };
    response: {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    };
    provider: {
        request?: any;
        response?: any;
    };
    metadataForCallbacks?: any;
}, {
    request: {
        config: Record<string, any>;
        messages: {
            role: "system" | "user" | "assistant" | "tool";
            content: ({
                value: string;
                modality: "text";
                metadata?: undefined;
            } | {
                value: {
                    type: "base64";
                    base64: string;
                    media_type: "png" | "jpeg" | "webp" | "gif";
                } | {
                    type: "url";
                    url: string;
                };
                modality: "image";
                detail: "low" | "medium" | "high" | "auto";
                metadata?: undefined;
            } | {
                id: string;
                name: string;
                modality: "tool-call";
                index: number;
                arguments: string;
                metadata?: undefined;
            } | {
                data: string;
                id: string;
                name: string;
                modality: "tool-response";
                index: number;
                metadata?: undefined;
            })[];
            metadata?: undefined;
        }[];
        tools?: {
            type: "function";
            definition: {
                schema: {
                    name: string;
                    description: string;
                    strict?: boolean | undefined;
                    parameters?: any;
                };
            };
            metadata?: any;
        }[] | undefined;
    };
    response: {
        partialMessages: {
            role: "assistant";
            partialContent: {
                value: string;
                modality: "partial-text";
                metadata?: undefined;
            } | {
                modality: "partial-tool-call";
                index: number;
                name?: string | undefined;
                metadata?: undefined;
                id?: string | undefined;
                arguments?: string | undefined;
            };
            metadata?: undefined;
        }[];
        usage?: {
            totalTokens: number;
            promptTokens: number;
            completionTokens: number;
        } | undefined;
        logProbs?: {
            token: string;
            logProb: number;
            bytes: number[] | null;
            topLogProbs: {
                token: string;
                logProb: number;
                bytes: number[] | null;
            }[];
        }[] | undefined;
    };
    provider: {
        request?: any;
        response?: any;
    };
    metadataForCallbacks?: any;
}>;
type StreamChatHandlerResponseType = z.infer<typeof StreamChatHandlerResponse>;
type StreamChatCallbackType<M = any> = {
    onStreamStart?: (metadata?: M) => Promise<void> | void;
    onStreamFirstResponse?: (metadata?: M, response?: StreamChatHandlerResponseType, chunk?: unknown) => Promise<void> | void;
    onStreamNewResponse?: (metadata?: M, response?: StreamChatHandlerResponseType, chunk?: unknown) => Promise<void> | void;
    onStreamEnd?: (metadata?: M, response?: StreamChatHandlerResponseType) => Promise<void> | void;
    onStreamError?: (metadata?: M, error?: GatewayError | HttpRequestError) => Promise<void> | void;
};

declare function handleStreamChat<M>(request: StreamChatHandlerRequestType, client: HttpClient, telemetryContext?: Context): AsyncGenerator<StreamChatHandlerResponseType, void, unknown>;

declare const GatewayOptions: z.ZodObject<{
    queueOptions: z.ZodOptional<z.ZodLazy<z.ZodObject<{
        maxConcurrentTasks: z.ZodOptional<z.ZodNumber>;
        retryCount: z.ZodOptional<z.ZodNumber>;
        timeout: z.ZodOptional<z.ZodNumber>;
        retry: z.ZodOptional<z.ZodObject<{
            initialDelay: z.ZodNumber;
            exponentialFactor: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            initialDelay: number;
            exponentialFactor: number;
        }, {
            initialDelay: number;
            exponentialFactor: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        timeout?: number | undefined;
        maxConcurrentTasks?: number | undefined;
        retryCount?: number | undefined;
        retry?: {
            initialDelay: number;
            exponentialFactor: number;
        } | undefined;
    }, {
        timeout?: number | undefined;
        maxConcurrentTasks?: number | undefined;
        retryCount?: number | undefined;
        retry?: {
            initialDelay: number;
            exponentialFactor: number;
        } | undefined;
    }>>>;
    dangerouslyAllowBrowser: z.ZodOptional<z.ZodBoolean>;
    httpClient: z.ZodOptional<z.ZodType<HttpClient, z.ZodTypeDef, HttpClient>>;
    completeChatCache: z.ZodOptional<z.ZodType<Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>, z.ZodTypeDef, Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>>>;
    completeChatCallbacks: z.ZodOptional<z.ZodArray<z.ZodType<CompleteChatCallbackType, z.ZodTypeDef, CompleteChatCallbackType>, "atleastone">>;
    getEmbeddingsCache: z.ZodOptional<z.ZodType<Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>, z.ZodTypeDef, Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>>>;
    getEmbeddingsCallbacks: z.ZodOptional<z.ZodArray<z.ZodType<GetEmbeddingsCallbackType, z.ZodTypeDef, GetEmbeddingsCallbackType>, "atleastone">>;
    streamChatCallbacks: z.ZodOptional<z.ZodArray<z.ZodType<StreamChatCallbackType, z.ZodTypeDef, StreamChatCallbackType>, "atleastone">>;
    logger: z.ZodOptional<z.ZodType<Logger, z.ZodTypeDef, Logger>>;
    telemetry: z.ZodOptional<z.ZodObject<{
        tracer: z.ZodOptional<z.ZodType<Tracer, z.ZodTypeDef, Tracer>>;
        meter: z.ZodOptional<z.ZodType<Meter, z.ZodTypeDef, Meter>>;
    }, "strip", z.ZodTypeAny, {
        tracer?: Tracer | undefined;
        meter?: Meter | undefined;
    }, {
        tracer?: Tracer | undefined;
        meter?: Meter | undefined;
    }>>;
    analyticsEnabled: z.ZodOptional<z.ZodBoolean>;
    enableProxyAgent: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    enableProxyAgent?: boolean | undefined;
    queueOptions?: {
        timeout?: number | undefined;
        maxConcurrentTasks?: number | undefined;
        retryCount?: number | undefined;
        retry?: {
            initialDelay: number;
            exponentialFactor: number;
        } | undefined;
    } | undefined;
    dangerouslyAllowBrowser?: boolean | undefined;
    httpClient?: HttpClient | undefined;
    completeChatCache?: Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }> | undefined;
    completeChatCallbacks?: [CompleteChatCallbackType, ...CompleteChatCallbackType[]] | undefined;
    getEmbeddingsCache?: Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }> | undefined;
    getEmbeddingsCallbacks?: [GetEmbeddingsCallbackType, ...GetEmbeddingsCallbackType[]] | undefined;
    streamChatCallbacks?: [StreamChatCallbackType, ...StreamChatCallbackType[]] | undefined;
    logger?: Logger | undefined;
    telemetry?: {
        tracer?: Tracer | undefined;
        meter?: Meter | undefined;
    } | undefined;
    analyticsEnabled?: boolean | undefined;
}, {
    enableProxyAgent?: boolean | undefined;
    queueOptions?: {
        timeout?: number | undefined;
        maxConcurrentTasks?: number | undefined;
        retryCount?: number | undefined;
        retry?: {
            initialDelay: number;
            exponentialFactor: number;
        } | undefined;
    } | undefined;
    dangerouslyAllowBrowser?: boolean | undefined;
    httpClient?: HttpClient | undefined;
    completeChatCache?: Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    data: string;
                    id: string;
                    name: string;
                    modality: "tool-response";
                    index: number;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        media_type: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-call";
                    index: number;
                    id: string;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    name: string;
                    modality: "tool-response";
                    index: number;
                    id: string;
                    data: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                totalTokens: number;
                promptTokens: number;
                completionTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }> | undefined;
    completeChatCallbacks?: [CompleteChatCallbackType, ...CompleteChatCallbackType[]] | undefined;
    getEmbeddingsCache?: Cache<{
        request: {
            config: Record<string, any>;
            embeddingRequests: {
                modality: "text";
                requests: string[];
                metadata?: undefined;
            } | {
                modality: "token";
                requests: number[][];
                metadata?: undefined;
            };
        };
        response: {
            encodingFormat: "float";
            embeddings: {
                index: number;
                embedding: number[];
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        } | {
            encodingFormat: "base64";
            embeddings: {
                index: number;
                embedding: string;
            }[];
            usage?: {
                totalTokens: number;
            } | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }> | undefined;
    getEmbeddingsCallbacks?: [GetEmbeddingsCallbackType, ...GetEmbeddingsCallbackType[]] | undefined;
    streamChatCallbacks?: [StreamChatCallbackType, ...StreamChatCallbackType[]] | undefined;
    logger?: Logger | undefined;
    telemetry?: {
        tracer?: Tracer | undefined;
        meter?: Meter | undefined;
    } | undefined;
    analyticsEnabled?: boolean | undefined;
}>;
type GatewayOptionsType = z.infer<typeof GatewayOptions>;
declare const GatewayCompleteChatRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    messages: z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
        content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
            modality: z.ZodLiteral<"text">;
            value: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"image">;
            detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                base64: z.ZodString;
                media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "url";
                url: string;
            }, {
                type: "url";
                url: string;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-call">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            arguments: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-response">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            data: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }>]>, "many">;
        metadata: z.ZodUndefined;
    }, "strip", z.ZodTypeAny, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }>, "many">;
    tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
        type: z.ZodEnum<["function"]>;
        definition: z.ZodObject<{
            schema: z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                parameters: z.ZodAny;
                strict: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }>;
        }, "strip", z.ZodTypeAny, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }>;
    }, {
        metadata: z.ZodTypeAny;
    }>, "strip", z.ZodTypeAny, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }>]>, "many">>;
    options: z.ZodOptional<z.ZodObject<{
        enableCache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        enableCache: boolean;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    }, {
        enableCache?: boolean | undefined;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    }>>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    options?: {
        enableCache: boolean;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    } | undefined;
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
}, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    options?: {
        enableCache?: boolean | undefined;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    } | undefined;
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
}>;
type GatewayCompleteChatRequestType = z.infer<typeof GatewayCompleteChatRequest>;
declare const GatewayStreamChatRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    messages: z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
        content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
            modality: z.ZodLiteral<"text">;
            value: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"image">;
            detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                base64: z.ZodString;
                media_type: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }, {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "url";
                url: string;
            }, {
                type: "url";
                url: string;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }, {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-call">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            arguments: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-response">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            data: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }, {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        }>]>, "many">;
        metadata: z.ZodUndefined;
    }, "strip", z.ZodTypeAny, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }>, "many">;
    tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
        type: z.ZodEnum<["function"]>;
        definition: z.ZodObject<{
            schema: z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                parameters: z.ZodAny;
                strict: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }>;
        }, "strip", z.ZodTypeAny, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }>;
    }, {
        metadata: z.ZodTypeAny;
    }>, "strip", z.ZodTypeAny, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }>]>, "many">>;
    options: z.ZodOptional<z.ZodObject<{
        customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    }, {
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    }>>;
    abortSignal: z.ZodOptional<z.ZodType<AbortSignal, z.ZodTypeDef, AbortSignal>>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    options?: {
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    } | undefined;
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
    abortSignal?: AbortSignal | undefined;
}, {
    config: Record<string, any>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                media_type: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            data: string;
            id: string;
            name: string;
            modality: "tool-response";
            index: number;
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    options?: {
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    } | undefined;
    tools?: {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
    }[] | undefined;
    abortSignal?: AbortSignal | undefined;
}>;
type GatewayStreamChatRequestType = z.infer<typeof GatewayStreamChatRequest>;
declare const GatewayGetEmbeddingsRequest: z.ZodObject<{
    model: z.ZodType<EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    embeddingRequests: z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
        modality: z.ZodLiteral<"text">;
        metadata: z.ZodUndefined;
        requests: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    }, {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    }>, z.ZodObject<{
        modality: z.ZodLiteral<"token">;
        metadata: z.ZodUndefined;
        requests: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
    }, "strip", z.ZodTypeAny, {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    }, {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    }>]>;
    options: z.ZodOptional<z.ZodObject<{
        enableCache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
        customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        metadataForCallbacks: z.ZodOptional<z.ZodAny>;
    }, "strip", z.ZodTypeAny, {
        enableCache: boolean;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    }, {
        enableCache?: boolean | undefined;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    }>>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    embeddingRequests: {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    } | {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    };
    options?: {
        enableCache: boolean;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    } | undefined;
}, {
    config: Record<string, any>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    embeddingRequests: {
        modality: "text";
        requests: string[];
        metadata?: undefined;
    } | {
        modality: "token";
        requests: number[][];
        metadata?: undefined;
    };
    options?: {
        enableCache?: boolean | undefined;
        customHeaders?: Record<string, string> | undefined;
        metadataForCallbacks?: any;
    } | undefined;
}>;
type GatewayGetEmbeddingsRequestType = z.infer<typeof GatewayGetEmbeddingsRequest>;
declare const GatewayProxyCompleteChatRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    data: z.ZodAny;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}>;
type GatewayProxyCompleteChatRequestType = z.infer<typeof GatewayProxyCompleteChatRequest>;
declare const GatewayProxyStreamChatRequest: z.ZodObject<{
    model: z.ZodType<ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    data: z.ZodAny;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}, {
    headers: Record<string, string>;
    model: ChatModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}>;
type GatewayProxyStreamChatRequestType = z.infer<typeof GatewayProxyStreamChatRequest>;
declare const GatewayProxyGetEmbeddingsRequest: z.ZodObject<{
    model: z.ZodType<EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>, z.ZodTypeDef, EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>>;
    data: z.ZodAny;
    headers: z.ZodRecord<z.ZodString, z.ZodString>;
    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    headers: Record<string, string>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}, {
    headers: Record<string, string>;
    model: EmbeddingModelV1<{
        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: "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 | null;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
    }>;
    data?: any;
    query?: Record<string, string> | undefined;
}>;
type GatewayProxyGetEmbeddingsRequestType = z.infer<typeof GatewayProxyGetEmbeddingsRequest>;

declare class Gateway {
    private options;
    private logger?;
    private tracer;
    private meter;
    private analytics;
    private httpClient;
    private queues;
    private caches;
    constructor(options?: GatewayOptionsType);
    completeChat(request: GatewayCompleteChatRequestType): Promise<CompleteChatHandlerResponseType>;
    private executeCompleteChat;
    streamChat(request: GatewayStreamChatRequestType): AsyncGenerator<StreamChatHandlerResponseType, void, unknown>;
    getEmbeddings(request: GatewayGetEmbeddingsRequestType): Promise<GetEmbeddingsHandlerResponseType>;
    private executeGetEmbeddings;
    proxyCompleteChat(request: GatewayProxyCompleteChatRequestType): Promise<ProxyCompleteChatHandlerResponseType>;
    private executeProxyCompleteChat;
    proxyStreamChat(request: GatewayProxyStreamChatRequestType): AsyncGenerator<ProxyStreamChatHandlerResponseType, void, unknown>;
    proxyGetEmbeddings(request: GatewayProxyGetEmbeddingsRequestType): Promise<ProxyGetEmbeddingsHandlerResponseType>;
    private executeProxyGetEmbeddings;
    static GatewayError: typeof GatewayError;
}

export { type AnalyticsBrowserEnvironment, type AnalyticsEvent, AnalyticsManager, type AnalyticsNodeEnvironment, type AnalyticsRecorder, type Cache, type CompleteChatCallbackType, CompleteChatHandlerRequest, type CompleteChatHandlerRequestType, CompleteChatHandlerResponse, type CompleteChatHandlerResponseType, ConsoleLogger, Gateway, GatewayError, type GatewayOptionsType, GatewayTelemetryError, type GetEmbeddingsCallbackType, GetEmbeddingsHandlerRequest, type GetEmbeddingsHandlerRequestType, GetEmbeddingsHandlerResponse, type GetEmbeddingsHandlerResponseType, type HttpClient, HttpClientError, type HttpClientResponse, HttpRequestError, IsomorphicHttpClient, LRUCache, type Logger, LoggerManager, NoOpAnalytics, PostAnalytics, ProxyCompleteChatHandlerRequest, type ProxyCompleteChatHandlerRequestType, ProxyCompleteChatHandlerResponse, type ProxyCompleteChatHandlerResponseType, ProxyGetEmbeddingsHandlerRequest, type ProxyGetEmbeddingsHandlerRequestType, ProxyGetEmbeddingsHandlerResponse, type ProxyGetEmbeddingsHandlerResponseType, ProxyStreamChatHandlerRequest, type ProxyStreamChatHandlerRequestType, ProxyStreamChatHandlerResponse, type ProxyStreamChatHandlerResponseType, type Queue, QueueOptions, type QueueOptionsType, type QueueTask, QueueTaskTimeoutError, SimpleQueue, type StreamChatCallbackType, StreamChatHandlerRequest, type StreamChatHandlerRequestType, StreamChatHandlerResponse, type StreamChatHandlerResponseType, TelemetryManager, handleCompleteChat, handleGetEmbeddings, handleProxyCompleteChat, handleProxyGetEmbeddings, handleProxyStreamChat, handleStreamChat };