type AuthToken = string | undefined;
interface Auth {
    /**
     * Which part of the request do we use to send the auth?
     *
     * @default 'header'
     */
    in?: 'header' | 'query' | 'cookie';
    /**
     * Header or query parameter name.
     *
     * @default 'Authorization'
     */
    name?: string;
    scheme?: 'basic' | 'bearer';
    type: 'apiKey' | 'http';
}

interface SerializerOptions<T> {
    /**
     * @default true
     */
    explode: boolean;
    style: T;
}
type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
type ObjectStyle = 'form' | 'deepObject';

type QuerySerializer = (query: Record<string, unknown>) => string;
type BodySerializer = (body: any) => any;
type QuerySerializerOptionsObject = {
    allowReserved?: boolean;
    array?: Partial<SerializerOptions<ArrayStyle>>;
    object?: Partial<SerializerOptions<ObjectStyle>>;
};
type QuerySerializerOptions = QuerySerializerOptionsObject & {
    /**
     * Per-parameter serialization overrides. When provided, these settings
     * override the global array/object settings for specific parameter names.
     */
    parameters?: Record<string, QuerySerializerOptionsObject>;
};

type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
    /**
     * Returns the final request URL.
     */
    buildUrl: BuildUrlFn;
    getConfig: () => Config;
    request: RequestFn;
    setConfig: (config: Config) => Config;
} & {
    [K in HttpMethod]: MethodFn;
} & ([SseFn] extends [never] ? {
    sse?: never;
} : {
    sse: {
        [K in HttpMethod]: SseFn;
    };
});
interface Config$1 {
    /**
     * Auth token or a function returning auth token. The resolved value will be
     * added to the request payload as defined by its `security` array.
     */
    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
    /**
     * A function for serializing request body parameter. By default,
     * {@link JSON.stringify()} will be used.
     */
    bodySerializer?: BodySerializer | null;
    /**
     * An object containing any HTTP headers that you want to pre-populate your
     * `Headers` object with.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
     */
    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
    /**
     * The request method.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
     */
    method?: Uppercase<HttpMethod>;
    /**
     * A function for serializing request query parameters. By default, arrays
     * will be exploded in form style, objects will be exploded in deepObject
     * style, and reserved characters are percent-encoded.
     *
     * This method will have no effect if the native `paramsSerializer()` Axios
     * API function is used.
     *
     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
     */
    querySerializer?: QuerySerializer | QuerySerializerOptions;
    /**
     * A function validating request data. This is useful if you want to ensure
     * the request conforms to the desired shape, so it can be safely sent to
     * the server.
     */
    requestValidator?: (data: unknown) => Promise<unknown>;
    /**
     * A function transforming response data before it's returned. This is useful
     * for post-processing data, e.g. converting ISO strings into Date objects.
     */
    responseTransformer?: (data: unknown) => Promise<unknown>;
    /**
     * A function validating response data. This is useful if you want to ensure
     * the response conforms to the desired shape, so it can be safely passed to
     * the transformers and returned to the user.
     */
    responseValidator?: (data: unknown) => Promise<unknown>;
}

type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
    /**
     * Fetch API implementation. You can use this option to provide a custom
     * fetch instance.
     *
     * @default globalThis.fetch
     */
    fetch?: typeof fetch;
    /**
     * Implementing clients can call request interceptors inside this hook.
     */
    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
    /**
     * Callback invoked when a network or parsing error occurs during streaming.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @param error The error that occurred.
     */
    onSseError?: (error: unknown) => void;
    /**
     * Callback invoked when an event is streamed from the server.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @param event Event streamed from the server.
     * @returns Nothing (void).
     */
    onSseEvent?: (event: StreamEvent<TData>) => void;
    serializedBody?: RequestInit['body'];
    /**
     * Default retry delay in milliseconds.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @default 3000
     */
    sseDefaultRetryDelay?: number;
    /**
     * Maximum number of retry attempts before giving up.
     */
    sseMaxRetryAttempts?: number;
    /**
     * Maximum retry delay in milliseconds.
     *
     * Applies only when exponential backoff is used.
     *
     * This option applies only if the endpoint returns a stream of events.
     *
     * @default 30000
     */
    sseMaxRetryDelay?: number;
    /**
     * Optional sleep function for retry backoff.
     *
     * Defaults to using `setTimeout`.
     */
    sseSleepFn?: (ms: number) => Promise<void>;
    url: string;
};
interface StreamEvent<TData = unknown> {
    data: TData;
    event?: string;
    id?: string;
    retry?: number;
}
type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
};

type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
declare class Interceptors<Interceptor> {
    fns: Array<Interceptor | null>;
    clear(): void;
    eject(id: number | Interceptor): void;
    exists(id: number | Interceptor): boolean;
    getInterceptorIndex(id: number | Interceptor): number;
    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
    use(fn: Interceptor): number;
}
interface Middleware<Req, Res, Err, Options> {
    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
    request: Interceptors<ReqInterceptor<Req, Options>>;
    response: Interceptors<ResInterceptor<Res, Req, Options>>;
}

type ResponseStyle = 'data' | 'fields';
interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
    /**
     * Base URL for all requests made by this client.
     */
    baseUrl?: T['baseUrl'];
    /**
     * Fetch API implementation. You can use this option to provide a custom
     * fetch instance.
     *
     * @default globalThis.fetch
     */
    fetch?: typeof fetch;
    /**
     * Please don't use the Fetch client for Next.js applications. The `next`
     * options won't have any effect.
     *
     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
     */
    next?: never;
    /**
     * Return the response data parsed in a specified format. By default, `auto`
     * will infer the appropriate method from the `Content-Type` response header.
     * You can override this behavior with any of the {@link Body} methods.
     * Select `stream` if you don't want to parse response data at all.
     *
     * @default 'auto'
     */
    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
    /**
     * Should we return only data or multiple fields (data, error, response, etc.)?
     *
     * @default 'fields'
     */
    responseStyle?: ResponseStyle;
    /**
     * Throw an error instead of returning it in the response?
     *
     * @default false
     */
    throwOnError?: T['throwOnError'];
}
interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
    responseStyle: TResponseStyle;
    throwOnError: ThrowOnError;
}>, Pick<ServerSentEventsOptions<TData>, 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
    /**
     * Any body that you want to add to your request.
     *
     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
     */
    body?: unknown;
    path?: Record<string, unknown>;
    query?: Record<string, unknown>;
    /**
     * Security mechanism(s) to use for the request.
     */
    security?: ReadonlyArray<Auth>;
    url: Url;
}
interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
    serializedBody?: string;
}
type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
    request: Request;
    response: Response;
}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
    error: undefined;
} | {
    data: undefined;
    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
}) & {
    request: Request;
    response: Response;
}>;
interface ClientOptions$1 {
    baseUrl?: string;
    responseStyle?: ResponseStyle;
    throwOnError?: boolean;
}
type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type BuildUrlFn = <TData extends {
    body?: unknown;
    path?: Record<string, unknown>;
    query?: Record<string, unknown>;
    url: string;
}>(options: TData & Options$1<TData>) => string;
type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
};
interface TDataShape {
    body?: unknown;
    headers?: unknown;
    path?: unknown;
    query?: unknown;
    url: string;
}
type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);

type ClientOptions = {
    baseUrl: 'https://edge.affectively.ai/v1' | 'https://edge.affectively.ai' | 'https://affectively-edge-dev.taylorbuley.workers.dev' | (string & {});
};
type ChatCompletionRequest = {
    /**
     * Model identifier. Can be:
     * - Text models: "mistral-7b", "llama-70b", "glm-4-9b", "glm-4.7", "qwen-edit", "tinyllama-1.1b", "deepseek-1.5b", "deepseek-3b"
     * - Vision: "flux-4b"
     * - Audio: "vibevoice-9b"
     * - Translation: "translategemma-4b"
     * - Special modes: "ensemble" (multiple models), "auto" (best available)
     *
     */
    model: string;
    /**
     * Array of message objects forming the conversation history.
     * Each message has a role (system, user, assistant) and content.
     *
     */
    messages: Array<Message>;
    /**
     * Controls randomness. Lower = more deterministic, Higher = more creative
     * - 0: Deterministic (best for analysis)
     * - 0.7: Balanced (recommended for most tasks)
     * - 1.5+: Creative (for brainstorming)
     *
     */
    temperature?: number;
    /**
     * Maximum number of tokens to generate
     */
    max_tokens?: number;
    /**
     * Nucleus sampling. Controls diversity of top choices.
     * Only used when temperature > 0
     *
     */
    top_p?: number;
    /**
     * Only sample from the K most likely tokens.
     * For reducing output variability without lowering temperature.
     *
     */
    top_k?: number;
    /**
     * For ensemble mode: array of model IDs to use.
     * Each model receives the same input and outputs are combined.
     *
     */
    models?: Array<string>;
    /**
     * How to combine ensemble results:
     * - weighted_average: Combine based on confidence scores
     * - voting: Majority rule
     * - consensus: Only return if models agree above threshold
     * - synthesis: AI-generated synthesis of perspectives
     *
     */
    ensemble_strategy?: 'weighted_average' | 'voting' | 'consensus' | 'synthesis';
    /**
     * Optional metadata for advanced modalities
     */
    metadata?: {
        /**
         * Enable multi-layer reasoning analysis
         */
        enable_meta_metacognition?: boolean;
        /**
         * Depth of self-reflection (1-5 layers)
         */
        reflection_depth?: number;
        /**
         * Enable probabilistic Monte Carlo analysis
         */
        enable_monte_carlo?: boolean;
        /**
         * Number of Monte Carlo iterations
         */
        iterations?: number;
        /**
         * Type of Monte Carlo analysis
         */
        analysis_type?: 'probability_estimation' | 'risk_analysis' | 'scenario_analysis';
        /**
         * Optional cache key for repeated requests
         */
        cache_key?: string;
    };
};
type Message = {
    /**
     * Role of the message sender
     */
    role: 'system' | 'user' | 'assistant';
    content: string | Array<{
        type?: string;
        text?: string;
    } | {
        type?: string;
        image_url?: {
            url?: string;
            detail?: 'low' | 'high';
        };
    }>;
};
type ChatCompletionResponse = {
    /**
     * Unique completion ID
     */
    id?: string;
    object?: 'chat.completion' | 'chat.completion.ensemble' | 'chat.completion.monte_carlo';
    /**
     * Unix timestamp of creation
     */
    created?: number;
    /**
     * Model used for completion
     */
    model?: string;
    usage?: Usage;
    choices?: Array<Choice>;
};
type Choice = {
    finish_reason?: 'stop' | 'length' | 'error';
    index?: number;
    message?: Message;
    /**
     * Results when using ensemble mode
     */
    ensemble_results?: {
        consensus_confidence?: number;
        perspectives?: Array<{
            [key: string]: unknown;
        }>;
    };
    /**
     * Results when using Monte Carlo analysis
     */
    monte_carlo_results?: {
        point_estimate?: number;
        confidence_interval?: {
            [key: string]: unknown;
        };
        standard_deviation?: number;
        iterations_converged?: number;
    };
};
type Usage = {
    /**
     * Number of tokens in the prompt
     */
    prompt_tokens?: number;
    /**
     * Number of tokens in the completion
     */
    completion_tokens?: number;
    /**
     * Total tokens used (prompt + completion)
     */
    total_tokens?: number;
};
type EmbeddingsRequest = {
    /**
     * Text or array of texts to embed
     */
    input: string | Array<string>;
    /**
     * Model to use for embeddings
     */
    model: string;
};
type EmbeddingsResponse = {
    object?: string;
    data?: Array<{
        object?: string;
        embedding?: Array<number>;
        index?: number;
    }>;
    model?: string;
    usage?: Usage;
};
type ModelsResponse = {
    object?: string;
    data?: Array<{
        id?: string;
        object?: string;
        created?: number;
        owned_by?: string;
        permissions?: Array<{
            [key: string]: unknown;
        }>;
        root?: string;
        parent?: string;
        context_window?: {
            input_tokens?: number;
            output_tokens?: number;
        };
        capabilities?: Array<'chat' | 'embeddings' | 'vision' | 'function_calling' | 'reasoning'>;
        rate_limit?: {
            requests_per_minute?: number;
            tokens_per_minute?: number;
        };
    }>;
};
type HealthResponse = {
    status?: 'operational' | 'degraded' | 'offline';
    timestamp?: string;
    gateway?: {
        status?: string;
        latency_ms?: number;
    };
    providers?: {
        [key: string]: {
            status?: string;
            latency_ms?: number;
            available_models?: number;
        };
    };
    rate_limits?: {
        current_usage?: number;
        limit?: number;
        reset_at?: string;
    };
    cache?: {
        hit_rate?: number;
        items_cached?: number;
    };
};
type ErrorResponse = {
    error?: {
        message?: string;
        type?: string;
        param?: string;
        code?: string;
    };
};
type RateLimitError = {
    error?: {
        type?: string;
        message?: string;
    };
    rate_limit?: {
        limit_per_minute?: number;
        remaining?: number;
        reset_in_seconds?: number;
    };
};
type CreateChatCompletionData = {
    body: ChatCompletionRequest;
    headers?: {
        /**
         * Optional request ID for tracking
         */
        'X-Request-ID'?: string;
        /**
         * Optional correlation ID for distributed tracing
         */
        'X-Correlation-ID'?: string;
    };
    path?: never;
    query?: never;
    url: '/chat/completions';
};
type CreateChatCompletionErrors = {
    /**
     * Invalid request parameters
     */
    400: ErrorResponse;
    /**
     * Rate limit exceeded
     */
    429: RateLimitError;
    /**
     * Server error
     */
    500: ErrorResponse;
};
type CreateChatCompletionError = CreateChatCompletionErrors[keyof CreateChatCompletionErrors];
type CreateChatCompletionResponses = {
    /**
     * Successful completion
     */
    200: ChatCompletionResponse;
};
type CreateChatCompletionResponse = CreateChatCompletionResponses[keyof CreateChatCompletionResponses];
type CreateEmbeddingsData = {
    body: EmbeddingsRequest;
    path?: never;
    query?: never;
    url: '/embeddings';
};
type CreateEmbeddingsErrors = {
    /**
     * Invalid request
     */
    400: ErrorResponse;
};
type CreateEmbeddingsError = CreateEmbeddingsErrors[keyof CreateEmbeddingsErrors];
type CreateEmbeddingsResponses = {
    /**
     * Successful embeddings generation
     */
    200: EmbeddingsResponse;
};
type CreateEmbeddingsResponse = CreateEmbeddingsResponses[keyof CreateEmbeddingsResponses];
type ListModelsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/models';
};
type ListModelsResponses = {
    /**
     * List of available models
     */
    200: ModelsResponse;
};
type ListModelsResponse = ListModelsResponses[keyof ListModelsResponses];
type GetHealthData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/health';
};
type GetHealthErrors = {
    /**
     * Gateway is unavailable
     */
    503: HealthResponse;
};
type GetHealthError = GetHealthErrors[keyof GetHealthErrors];
type GetHealthResponses = {
    /**
     * Gateway is operational
     */
    200: HealthResponse;
};
type GetHealthResponse = GetHealthResponses[keyof GetHealthResponses];

type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options$1<TData, ThrowOnError> & {
    /**
     * You can provide a client instance returned by `createClient()` instead of
     * individual options. This might be also useful if you want to implement a
     * custom client.
     */
    client?: Client;
    /**
     * You can pass arbitrary values through the `meta` object. This can be
     * used to access values that aren't defined as part of the SDK function.
     */
    meta?: Record<string, unknown>;
};
/**
 * Create chat completion
 *
 * Generate text responses using a specified language model.
 *
 * ## Advanced Modalities
 *
 * ### Ensemble Mode
 * Sends the same prompt to multiple models and combines responses intelligently:
 * - **Ensemble Cost**: Input tokens charged once; output tokens for each model
 * - **Use Cases**: High-stakes decisions requiring diverse perspectives
 * - **Response Merging**: Results are combined based on agreement and confidence
 *
 * ### Meta-Metacognition
 * Enables multi-layer reasoning where models analyze their own reasoning:
 * - **Layer 1**: Initial response generation
 * - **Layer 2**: Self-reflection on reasoning process
 * - **Layer 3**: Meta-analysis of reflection quality
 * - **Cost Impact**: 3x token usage (one per layer)
 * - **Benefit**: More nuanced, self-aware responses
 *
 * ### Monte Carlo Analysis
 * Runs multiple probabilistic iterations to handle uncertainty:
 * - **Iterations**: Configurable (typically 5-20 runs)
 * - **Token Cost**: `num_iterations × base_tokens`
 * - **Use Cases**: Probability estimation, scenario analysis, risk assessment
 * - **Convergence**: Results stabilize with more iterations
 * - **Standard Deviation**: Measure of response variability
 *
 */
declare const createChatCompletion: <ThrowOnError extends boolean = false>(options: Options<CreateChatCompletionData, ThrowOnError>) => RequestResult<CreateChatCompletionResponses, CreateChatCompletionErrors, ThrowOnError, "fields">;
/**
 * Create embeddings
 *
 * Generate vector embeddings for text, enabling semantic search and similarity analysis.
 *
 * ## Use Cases
 * - Semantic search across emotions and reflections
 * - Clustering similar emotional states
 * - Finding related tools or coping strategies
 * - Recommendation systems
 *
 * ## Token Counting
 * Embeddings count tokens the same as chat completions.
 * All models are self-hosted with no per-token costs.
 *
 */
declare const createEmbeddings: <ThrowOnError extends boolean = false>(options: Options<CreateEmbeddingsData, ThrowOnError>) => RequestResult<CreateEmbeddingsResponses, CreateEmbeddingsErrors, ThrowOnError, "fields">;
/**
 * List available models
 *
 * Retrieve information about all available models and their capabilities.
 *
 * Returns model details including:
 * - Model ID and name
 * - Provider (Cloudflare Workers or Cloud Run)
 * - Capabilities (chat, embeddings, vision, audio, translation)
 * - Token limits (input/output context windows)
 * - Rate limits
 * - Latest update
 *
 * ## Text Models
 * - mistral-7b, llama-70b, llama-13b, glm-4.7, qwen-edit
 * - tinyllama-1.1b, deepseek-1.5b, deepseek-3b
 *
 * ## Vision/Audio/Translation Models
 * - flux-4b (image generation)
 * - vibevoice-9b (TTS)
 * - translategemma-4b (translation)
 *
 */
declare const listModels: <ThrowOnError extends boolean = false>(options?: Options<ListModelsData, ThrowOnError>) => RequestResult<ListModelsResponses, unknown, ThrowOnError, "fields">;
/**
 * Health check
 *
 * Check the health status of the AI Gateway and all connected providers.
 *
 * Returns status information including:
 * - Gateway status (operational/degraded/offline)
 * - Provider status (each provider's current status)
 * - Rate limit status (current usage vs limits)
 * - Token counter status
 * - Cache status
 *
 */
declare const getHealth: <ThrowOnError extends boolean = false>(options?: Options<GetHealthData, ThrowOnError>) => RequestResult<GetHealthResponses, GetHealthErrors, ThrowOnError, "fields">;

type index_ChatCompletionRequest = ChatCompletionRequest;
type index_ChatCompletionResponse = ChatCompletionResponse;
type index_Choice = Choice;
type index_ClientOptions = ClientOptions;
type index_CreateChatCompletionData = CreateChatCompletionData;
type index_CreateChatCompletionError = CreateChatCompletionError;
type index_CreateChatCompletionErrors = CreateChatCompletionErrors;
type index_CreateChatCompletionResponse = CreateChatCompletionResponse;
type index_CreateChatCompletionResponses = CreateChatCompletionResponses;
type index_CreateEmbeddingsData = CreateEmbeddingsData;
type index_CreateEmbeddingsError = CreateEmbeddingsError;
type index_CreateEmbeddingsErrors = CreateEmbeddingsErrors;
type index_CreateEmbeddingsResponse = CreateEmbeddingsResponse;
type index_CreateEmbeddingsResponses = CreateEmbeddingsResponses;
type index_EmbeddingsRequest = EmbeddingsRequest;
type index_EmbeddingsResponse = EmbeddingsResponse;
type index_ErrorResponse = ErrorResponse;
type index_GetHealthData = GetHealthData;
type index_GetHealthError = GetHealthError;
type index_GetHealthErrors = GetHealthErrors;
type index_GetHealthResponse = GetHealthResponse;
type index_GetHealthResponses = GetHealthResponses;
type index_HealthResponse = HealthResponse;
type index_ListModelsData = ListModelsData;
type index_ListModelsResponse = ListModelsResponse;
type index_ListModelsResponses = ListModelsResponses;
type index_Message = Message;
type index_ModelsResponse = ModelsResponse;
type index_Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options<TData, ThrowOnError>;
type index_RateLimitError = RateLimitError;
type index_Usage = Usage;
declare const index_createChatCompletion: typeof createChatCompletion;
declare const index_createEmbeddings: typeof createEmbeddings;
declare const index_getHealth: typeof getHealth;
declare const index_listModels: typeof listModels;
declare namespace index {
  export { type index_ChatCompletionRequest as ChatCompletionRequest, type index_ChatCompletionResponse as ChatCompletionResponse, type index_Choice as Choice, type index_ClientOptions as ClientOptions, type index_CreateChatCompletionData as CreateChatCompletionData, type index_CreateChatCompletionError as CreateChatCompletionError, type index_CreateChatCompletionErrors as CreateChatCompletionErrors, type index_CreateChatCompletionResponse as CreateChatCompletionResponse, type index_CreateChatCompletionResponses as CreateChatCompletionResponses, type index_CreateEmbeddingsData as CreateEmbeddingsData, type index_CreateEmbeddingsError as CreateEmbeddingsError, type index_CreateEmbeddingsErrors as CreateEmbeddingsErrors, type index_CreateEmbeddingsResponse as CreateEmbeddingsResponse, type index_CreateEmbeddingsResponses as CreateEmbeddingsResponses, type index_EmbeddingsRequest as EmbeddingsRequest, type index_EmbeddingsResponse as EmbeddingsResponse, type index_ErrorResponse as ErrorResponse, type index_GetHealthData as GetHealthData, type index_GetHealthError as GetHealthError, type index_GetHealthErrors as GetHealthErrors, type index_GetHealthResponse as GetHealthResponse, type index_GetHealthResponses as GetHealthResponses, type index_HealthResponse as HealthResponse, type index_ListModelsData as ListModelsData, type index_ListModelsResponse as ListModelsResponse, type index_ListModelsResponses as ListModelsResponses, type index_Message as Message, type index_ModelsResponse as ModelsResponse, type index_Options as Options, type index_RateLimitError as RateLimitError, type index_Usage as Usage, index_createChatCompletion as createChatCompletion, index_createEmbeddings as createEmbeddings, index_getHealth as getHealth, index_listModels as listModels };
}

export { listModels as A, type ChatCompletionRequest as C, type EmbeddingsRequest as E, type GetHealthData as G, type HealthResponse as H, type ListModelsData as L, type Message as M, type Options as O, type RateLimitError as R, type Usage as U, type ChatCompletionResponse as a, type Choice as b, type ClientOptions as c, type CreateChatCompletionData as d, type CreateChatCompletionError as e, type CreateChatCompletionErrors as f, type CreateChatCompletionResponse as g, type CreateChatCompletionResponses as h, index as i, type CreateEmbeddingsData as j, type CreateEmbeddingsError as k, type CreateEmbeddingsErrors as l, type CreateEmbeddingsResponse as m, type CreateEmbeddingsResponses as n, type EmbeddingsResponse as o, type ErrorResponse as p, type GetHealthError as q, type GetHealthErrors as r, type GetHealthResponse as s, type GetHealthResponses as t, type ListModelsResponse as u, type ListModelsResponses as v, type ModelsResponse as w, createChatCompletion as x, createEmbeddings as y, getHealth as z };