@reverbia/sdk 1.0.0 → 1.1.0-next.20251230221037

package/dist/index.d.mts

@@ -0,0 +1,1514 @@
+type ClientOptions$1 = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+type HandlersConfigResponse = {
+    /**
+     * ChainID is the blockchain chain ID
+     */
+    chain_id?: string;
+    /**
+     * CostLimitEscrowAddress is the cost-limit escrow contract address (if configured)
+     */
+    cost_limit_escrow_address?: string;
+    /**
+     * OperatorAddress is the operator wallet address
+     */
+    operator_address?: string;
+    /**
+     * PayAsYouGoEscrowAddress is the pay-as-you-go escrow contract address (if configured)
+     */
+    pay_as_you_go_escrow_address?: string;
+    /**
+     * PaymentModel is the payment model used (pay_as_you_go or cost_limit)
+     */
+    payment_model?: string;
+    /**
+     * SettlementRecipient is the address that receives settlement payments
+     */
+    settlement_recipient?: string;
+};
+type HandlersExchangeRequest = {
+    code: string;
+    /**
+     * Optional - uses config default if not provided
+     */
+    redirect_uri?: string;
+};
+type HandlersHealthResponse = {
+    /**
+     * Status indicates the service health status
+     */
+    status?: string;
+    /**
+     * Timestamp is the Unix timestamp of the response
+     */
+    timestamp?: number;
+    /**
+     * Version is the current API version
+     */
+    version?: string;
+};
+type HandlersRefreshRequest = {
+    refresh_token: string;
+};
+type HandlersRevokeRequest = {
+    token: string;
+};
+type HandlersTokenResponse = {
+    access_token?: string;
+    /**
+     * Seconds until expiration
+     */
+    expires_in?: number;
+    /**
+     * May not be present on refresh
+     */
+    refresh_token?: string;
+    /**
+     * Granted scopes
+     */
+    scope?: string;
+    /**
+     * Usually "Bearer"
+     */
+    token_type?: string;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiChatCompletionExtraFields = {
+    /**
+     * Latency is the request latency in milliseconds
+     */
+    latency?: number;
+    /**
+     * ModelRequested is the model that was requested
+     */
+    model_requested?: string;
+    /**
+     * Provider is the LLM provider used (e.g., "openai", "anthropic")
+     */
+    provider?: string;
+    /**
+     * RequestType is always "chat_completion"
+     */
+    request_type?: string;
+};
+type LlmapiChatCompletionRequest = {
+    /**
+     * Messages is the conversation history
+     */
+    messages: Array<LlmapiMessage>;
+    /**
+     * Model is the model identifier
+     */
+    model: string;
+    /**
+     * Stream indicates if response should be streamed
+     */
+    stream?: boolean;
+};
+type LlmapiChatCompletionResponse = {
+    /**
+     * Choices contains the completion choices
+     */
+    choices?: Array<LlmapiChoice>;
+    extra_fields?: LlmapiChatCompletionExtraFields;
+    /**
+     * ID is the completion ID
+     */
+    id?: string;
+    /**
+     * Model is the model used
+     */
+    model?: string;
+    usage?: LlmapiChatCompletionUsage;
+};
+/**
+ * Usage contains token usage information
+ */
+type LlmapiChatCompletionUsage = {
+    /**
+     * CompletionTokens is the number of tokens in the completion
+     */
+    completion_tokens?: number;
+    /**
+     * CostMicroUSD is the cost of this completion in micro-dollars (USD × 1,000,000)
+     */
+    cost_micro_usd?: number;
+    /**
+     * PromptTokens is the number of tokens in the prompt
+     */
+    prompt_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens used
+     */
+    total_tokens?: number;
+};
+type LlmapiChoice = {
+    /**
+     * FinishReason indicates why the completion stopped
+     */
+    finish_reason?: string;
+    /**
+     * Index is the choice index
+     */
+    index?: number;
+    message?: LlmapiMessage;
+};
+type LlmapiEmbeddingData = {
+    /**
+     * Embedding vector
+     */
+    embedding?: Array<number>;
+    /**
+     * Index of the embedding
+     */
+    index?: number;
+    /**
+     * Object type identifier
+     */
+    object?: string;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiEmbeddingExtraFields = {
+    /**
+     * ChunkIndex is the chunk index (0 for single requests)
+     */
+    chunk_index?: number;
+    /**
+     * Latency is the request latency in milliseconds
+     */
+    latency?: number;
+    /**
+     * ModelRequested is the model that was requested
+     */
+    model_requested?: string;
+    /**
+     * Provider is the LLM provider used (e.g., "openai", "anthropic")
+     */
+    provider?: string;
+    /**
+     * RequestType is always "embedding"
+     */
+    request_type?: string;
+};
+type LlmapiEmbeddingRequest = {
+    /**
+     * Dimensions is the number of dimensions the resulting output embeddings should have (optional)
+     */
+    dimensions?: number;
+    /**
+     * EncodingFormat is the format to return the embeddings in (optional: "float" or "base64")
+     */
+    encoding_format?: string;
+    /**
+     * Input text or tokens to embed (can be string, []string, []int, or [][]int)
+     */
+    input: unknown;
+    /**
+     * Model identifier in 'provider/model' format
+     */
+    model: string;
+};
+type LlmapiEmbeddingResponse = {
+    /**
+     * Data contains the embeddings
+     */
+    data?: Array<LlmapiEmbeddingData>;
+    extra_fields?: LlmapiEmbeddingExtraFields;
+    /**
+     * Model is the model used
+     */
+    model?: string;
+    /**
+     * Object is always "list"
+     */
+    object?: string;
+    usage?: LlmapiEmbeddingUsage;
+};
+/**
+ * Usage contains token usage information
+ */
+type LlmapiEmbeddingUsage = {
+    /**
+     * CostMicroUSD is the inference cost for this embedding request
+     */
+    cost_micro_usd?: number;
+    /**
+     * PromptTokens is the number of tokens in the prompt
+     */
+    prompt_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens used
+     */
+    total_tokens?: number;
+};
+/**
+ * ExtraFields contains additional metadata such as provider/model information.
+ */
+type LlmapiImageGenerationExtraFields = {
+    /**
+     * ModelRequested is the model identifier that the client asked for.
+     */
+    model_requested?: string;
+    /**
+     * Provider is the gateway that serviced this request.
+     */
+    provider?: string;
+    /**
+     * RequestType is always "image_generation".
+     */
+    request_type?: string;
+};
+type LlmapiImageGenerationImage = {
+    /**
+     * B64JSON is the base64 payload for models that can only return binary.
+     */
+    b64_json?: string;
+    /**
+     * URL is the signed URL to download the image.
+     */
+    url?: string;
+};
+type LlmapiImageGenerationRequest = {
+    /**
+     * Model is the model identifier to use for generation (e.g., "gpt-image-1").
+     */
+    model: string;
+    /**
+     * Prompt is the text description of the desired image.
+     */
+    prompt: string;
+    /**
+     * Quality targets a quality preset (e.g., "auto", "high").
+     */
+    quality?: string;
+    /**
+     * ResponseFormat controls how the generated image is returned (e.g., "url" or "b64_json").
+     */
+    response_format?: string;
+    /**
+     * Size controls the dimensions of the generated image (e.g., "1024x1024").
+     */
+    size?: string;
+};
+type LlmapiImageGenerationResponse = {
+    /**
+     * Created is the Unix timestamp when the image was generated.
+     */
+    created?: number;
+    extra_fields?: LlmapiImageGenerationExtraFields;
+    /**
+     * Images contains the generated images.
+     */
+    images?: Array<LlmapiImageGenerationImage>;
+    /**
+     * Model is the model identifier that generated the image.
+     */
+    model?: string;
+    /**
+     * Provider is the gateway that produced the image.
+     */
+    provider?: string;
+    usage?: LlmapiImageGenerationUsage;
+};
+/**
+ * Usage documents token usage (when available).
+ */
+type LlmapiImageGenerationUsage = {
+    /**
+     * CostMicroUSD is the inference cost for this image generation request
+     */
+    cost_micro_usd?: number;
+    /**
+     * InputTokens is the number of tokens sent in the prompt.
+     */
+    input_tokens?: number;
+    /**
+     * OutputTokens is the number of tokens returned by the model.
+     */
+    output_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens consumed.
+     */
+    total_tokens?: number;
+};
+/**
+ * Message is the generated message
+ */
+type LlmapiMessage = {
+    /**
+     * Content is the message content
+     */
+    content?: Array<LlmapiMessageContentPart>;
+    role?: LlmapiRole;
+    /**
+     * ToolCalls contains tool/function calls made by the assistant (only for assistant role)
+     */
+    tool_calls?: Array<LlmapiToolCall>;
+};
+/**
+ * ImageURL is used when Type=image_url
+ */
+type LlmapiMessageContentImage = {
+    /**
+     * Detail is the OpenAI detail hint (auto|low|high)
+     */
+    detail?: string;
+    /**
+     * URL is the image URL or data URI
+     */
+    url?: string;
+};
+type LlmapiMessageContentPart = {
+    image_url?: LlmapiMessageContentImage;
+    /**
+     * Text holds the text content when Type=text
+     */
+    text?: string;
+    /**
+     * Type is the block type (`text` or `image_url`)
+     */
+    type?: string;
+};
+type LlmapiModel = {
+    architecture?: LlmapiModelArchitecture;
+    /**
+     * CanonicalSlug is the canonical slug for the model
+     */
+    canonical_slug?: string;
+    /**
+     * ContextLength is the maximum context length in tokens
+     */
+    context_length?: number;
+    /**
+     * Created is the Unix timestamp of when the model was created
+     */
+    created?: number;
+    /**
+     * DefaultParameters contains default parameter values
+     */
+    default_parameters?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Description describes the model and its capabilities
+     */
+    description?: string;
+    /**
+     * HuggingFaceID is the Hugging Face model identifier
+     */
+    hugging_face_id?: string;
+    /**
+     * ID is the model identifier (e.g., "openai/gpt-4")
+     */
+    id?: string;
+    /**
+     * MaxInputTokens is the maximum input tokens
+     */
+    max_input_tokens?: number;
+    /**
+     * MaxOutputTokens is the maximum output tokens
+     */
+    max_output_tokens?: number;
+    /**
+     * Modalities is a list of supported modalities (e.g., ["llm", "vision"])
+     */
+    modalities?: Array<string>;
+    /**
+     * Name is the human-readable model name (optional)
+     */
+    name?: string;
+    /**
+     * OwnedBy is the organization that owns the model
+     */
+    owned_by?: string;
+    per_request_limits?: LlmapiModelPerRequestLimits;
+    pricing?: LlmapiModelPricing;
+    /**
+     * SupportedMethods is a list of supported API methods
+     */
+    supported_methods?: Array<string>;
+    /**
+     * SupportedParameters is a list of supported parameter names
+     */
+    supported_parameters?: Array<string>;
+    top_provider?: LlmapiModelTopProvider;
+};
+/**
+ * Architecture describes the model's technical capabilities
+ */
+type LlmapiModelArchitecture = {
+    instruct_type?: string;
+    modality?: string;
+    prompt_formatting?: string;
+    tokenizer?: string;
+};
+/**
+ * PerRequestLimits contains rate limiting information
+ */
+type LlmapiModelPerRequestLimits = {
+    completion_tokens?: number;
+    prompt_tokens?: number;
+};
+/**
+ * Pricing contains the pricing structure for using this model
+ */
+type LlmapiModelPricing = {
+    completion?: string;
+    image?: string;
+    prompt?: string;
+    request?: string;
+};
+/**
+ * TopProvider contains configuration details for the primary provider
+ */
+type LlmapiModelTopProvider = {
+    context_length?: number;
+    is_moderated?: boolean;
+    max_completion_tokens?: number;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiModelsListExtraFields = {
+    /**
+     * ChunkIndex is the chunk index (0 for single requests)
+     */
+    chunk_index?: number;
+    /**
+     * Latency is the request latency in milliseconds
+     */
+    latency?: number;
+    /**
+     * RequestType is always "list_models"
+     */
+    request_type?: string;
+};
+type LlmapiModelsListResponse = {
+    /**
+     * Data contains the list of available models
+     */
+    data?: Array<LlmapiModel>;
+    extra_fields?: LlmapiModelsListExtraFields;
+    /**
+     * NextPageToken is the token to retrieve the next page of results (omitted if no more pages)
+     */
+    next_page_token?: string;
+};
+/**
+ * ExtraFields contains additional metadata
+ */
+type LlmapiResponseExtraFields = {
+    /**
+     * Latency is the request latency in milliseconds
+     */
+    latency?: number;
+    /**
+     * ModelRequested is the model that was requested
+     */
+    model_requested?: string;
+    /**
+     * Provider is the LLM provider used (e.g., "openai", "anthropic")
+     */
+    provider?: string;
+    /**
+     * RequestType is always "responses"
+     */
+    request_type?: string;
+};
+type LlmapiResponseOutputContent = {
+    /**
+     * Text is the text content
+     */
+    text?: string;
+    /**
+     * Type is the content type (e.g., "output_text")
+     */
+    type?: string;
+};
+type LlmapiResponseOutputItem = {
+    /**
+     * Arguments is the function arguments for function_call types
+     */
+    arguments?: string;
+    /**
+     * CallID is the call ID for function_call types
+     */
+    call_id?: string;
+    /**
+     * Content is the content array for message and reasoning types
+     */
+    content?: Array<LlmapiResponseOutputContent>;
+    /**
+     * ID is the unique identifier for this output item
+     */
+    id?: string;
+    /**
+     * Name is the function name for function_call types
+     */
+    name?: string;
+    /**
+     * Role is the role for message types (e.g., "assistant")
+     */
+    role?: string;
+    /**
+     * Status is the status of this output item (e.g., "completed")
+     */
+    status?: string;
+    /**
+     * Summary is the reasoning summary for reasoning types
+     */
+    summary?: Array<LlmapiResponseOutputContent>;
+    /**
+     * Type is the output item type (e.g., "message", "function_call", "reasoning")
+     */
+    type?: string;
+};
+/**
+ * Reasoning configures reasoning for o-series and other reasoning models
+ */
+type LlmapiResponseReasoning = {
+    /**
+     * Effort controls reasoning effort: "low", "medium", or "high"
+     */
+    effort?: string;
+    /**
+     * Summary controls reasoning summary: "auto", "concise", or "detailed"
+     */
+    summary?: string;
+};
+type LlmapiResponseRequest = {
+    /**
+     * Background indicates if request should be processed in background
+     */
+    background?: boolean;
+    /**
+     * Conversation is the conversation ID (optional)
+     */
+    conversation?: string;
+    /**
+     * Input is the simple text input for the response
+     */
+    input: string;
+    /**
+     * MaxOutputTokens is the maximum number of tokens to generate
+     */
+    max_output_tokens?: number;
+    /**
+     * Model is the model identifier in 'provider/model' format
+     */
+    model: string;
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Stream indicates if response should be streamed
+     */
+    stream?: boolean;
+    /**
+     * Temperature controls randomness (0.0 to 2.0)
+     */
+    temperature?: number;
+    thinking?: LlmapiThinkingOptions;
+    /**
+     * ToolChoice controls which tool to use (auto, any, none, required, or tool name)
+     */
+    tool_choice?: string;
+    /**
+     * Tools is an array of tool definitions (passed through, no MCP loop)
+     */
+    tools?: Array<LlmapiTool>;
+};
+type LlmapiResponseResponse = {
+    /**
+     * Created is the Unix timestamp of creation (created_at in OpenAI format)
+     */
+    created_at?: number;
+    extra_fields?: LlmapiResponseExtraFields;
+    /**
+     * ID is the unique response identifier
+     */
+    id?: string;
+    /**
+     * Model is the model used for generation
+     */
+    model?: string;
+    /**
+     * Object is the response type (e.g., "response")
+     */
+    object?: string;
+    /**
+     * Output is the array of output items (OpenAI Responses API format)
+     */
+    output?: Array<LlmapiResponseOutputItem>;
+    usage?: LlmapiResponseUsage;
+};
+/**
+ * Usage contains token usage information
+ */
+type LlmapiResponseUsage = {
+    /**
+     * CompletionTokens is the number of tokens in the completion
+     */
+    completion_tokens?: number;
+    /**
+     * CostMicroUSD is the cost of this response in micro-dollars (USD × 1,000,000)
+     */
+    cost_micro_usd?: number;
+    /**
+     * PromptTokens is the number of tokens in the prompt
+     */
+    prompt_tokens?: number;
+    /**
+     * TotalTokens is the total number of tokens used
+     */
+    total_tokens?: number;
+};
+/**
+ * Role is the message role (system, user, assistant)
+ */
+type LlmapiRole = string;
+/**
+ * ExtraFields contains additional metadata.
+ */
+type LlmapiSearchExtraFields = {
+    /**
+     * RequestType is always "search".
+     */
+    request_type?: string;
+    /**
+     * SearchProvider is the search provider used (e.g., "perplexity", "google-pse").
+     */
+    search_provider?: string;
+};
+type LlmapiSearchRequest = {
+    /**
+     * Country code filter (e.g., "US", "GB", "DE").
+     */
+    country?: string;
+    /**
+     * Maximum number of results to return (1-20). Default: 10.
+     */
+    max_results?: number;
+    /**
+     * Maximum tokens per page to process. Default: 1024.
+     */
+    max_tokens_per_page?: number;
+    /**
+     * Search query. Can be a single string or array of strings.
+     */
+    query: Array<string>;
+    /**
+     * List of domains to filter results (max 20 domains).
+     */
+    search_domain_filter?: Array<string>;
+    /**
+     * The search provider to use.
+     */
+    search_tool_name: string;
+};
+type LlmapiSearchResponse = {
+    extra_fields?: LlmapiSearchExtraFields;
+    /**
+     * List of search results.
+     */
+    results?: Array<LlmapiSearchResult>;
+    usage?: LlmapiSearchUsage;
+};
+type LlmapiSearchResult = {
+    /**
+     * Optional publication or last updated date.
+     */
+    date?: string;
+    /**
+     * Text snippet from the result.
+     */
+    snippet?: string;
+    /**
+     * Title of the search result.
+     */
+    title?: string;
+    /**
+     * URL of the search result.
+     */
+    url?: string;
+};
+/**
+ * Usage contains usage information.
+ */
+type LlmapiSearchUsage = {
+    /**
+     * CostMicroUSD is the cost of this search in micro-dollars (USD × 1,000,000).
+     */
+    cost_micro_usd?: number;
+};
+/**
+ * Thinking configures extended thinking for Anthropic models
+ */
+type LlmapiThinkingOptions = {
+    /**
+     * BudgetTokens is the token budget for thinking
+     */
+    budget_tokens?: number;
+    /**
+     * Type indicates if thinking is enabled: "enabled" or "disabled"
+     */
+    type?: string;
+};
+type LlmapiTool = {
+    function?: LlmapiToolFunction;
+    /**
+     * Type is the tool type (function, code_interpreter, file_search, web_search)
+     */
+    type?: string;
+};
+type LlmapiToolCall = {
+    function?: LlmapiToolCallFunction;
+    /**
+     * ID is the unique identifier for this tool call
+     */
+    id?: string;
+    /**
+     * Type is the type of tool call (always "function" for now)
+     */
+    type?: string;
+};
+/**
+ * Function contains the function call details
+ */
+type LlmapiToolCallFunction = {
+    /**
+     * Arguments is the JSON string of arguments to pass to the function
+     */
+    arguments?: string;
+    /**
+     * Name is the name of the function to call
+     */
+    name?: string;
+};
+/**
+ * Function is the function definition (when Type is "function")
+ */
+type LlmapiToolFunction = {
+    /**
+     * Arguments is the function arguments schema (JSON object)
+     */
+    arguments?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Name is the function name
+     */
+    name?: string;
+};
+type ResponseErrorResponse = {
+    error?: string;
+};
+type PostApiV1ChatCompletionsData = {
+    /**
+     * Chat completion request
+     */
+    body: LlmapiChatCompletionRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/chat/completions';
+};
+type PostApiV1ChatCompletionsErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostApiV1ChatCompletionsError = PostApiV1ChatCompletionsErrors[keyof PostApiV1ChatCompletionsErrors];
+type PostApiV1ChatCompletionsResponses = {
+    /**
+     * OK
+     */
+    200: LlmapiChatCompletionResponse | string;
+};
+type PostApiV1ChatCompletionsResponse = PostApiV1ChatCompletionsResponses[keyof PostApiV1ChatCompletionsResponses];
+type GetApiV1ConfigData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/config';
+};
+type GetApiV1ConfigErrors = {
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type GetApiV1ConfigError = GetApiV1ConfigErrors[keyof GetApiV1ConfigErrors];
+type GetApiV1ConfigResponses = {
+    /**
+     * OK
+     */
+    200: HandlersConfigResponse;
+};
+type GetApiV1ConfigResponse = GetApiV1ConfigResponses[keyof GetApiV1ConfigResponses];
+type GetApiV1DocsSwaggerJsonData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/docs/swagger.json';
+};
+type GetApiV1DocsSwaggerJsonResponses = {
+    /**
+     * OK
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+type GetApiV1DocsSwaggerJsonResponse = GetApiV1DocsSwaggerJsonResponses[keyof GetApiV1DocsSwaggerJsonResponses];
+type PostApiV1EmbeddingsData = {
+    /**
+     * Embedding request
+     */
+    body: LlmapiEmbeddingRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/embeddings';
+};
+type PostApiV1EmbeddingsErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostApiV1EmbeddingsError = PostApiV1EmbeddingsErrors[keyof PostApiV1EmbeddingsErrors];
+type PostApiV1EmbeddingsResponses = {
+    /**
+     * OK
+     */
+    200: LlmapiEmbeddingResponse;
+};
+type PostApiV1EmbeddingsResponse = PostApiV1EmbeddingsResponses[keyof PostApiV1EmbeddingsResponses];
+type PostApiV1ImagesGenerationsData = {
+    /**
+     * Image generation request
+     */
+    body: LlmapiImageGenerationRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/images/generations';
+};
+type PostApiV1ImagesGenerationsErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+    /**
+     * Not Implemented
+     */
+    501: ResponseErrorResponse;
+};
+type PostApiV1ImagesGenerationsError = PostApiV1ImagesGenerationsErrors[keyof PostApiV1ImagesGenerationsErrors];
+type PostApiV1ImagesGenerationsResponses = {
+    /**
+     * OK
+     */
+    200: LlmapiImageGenerationResponse;
+};
+type PostApiV1ImagesGenerationsResponse = PostApiV1ImagesGenerationsResponses[keyof PostApiV1ImagesGenerationsResponses];
+type GetApiV1ModelsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by provider (e.g., openai, anthropic)
+         */
+        provider?: string;
+        /**
+         * Number of models to return per page
+         */
+        page_size?: number;
+        /**
+         * Token to get next page of results
+         */
+        page_token?: string;
+    };
+    url: '/api/v1/models';
+};
+type GetApiV1ModelsErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type GetApiV1ModelsError = GetApiV1ModelsErrors[keyof GetApiV1ModelsErrors];
+type GetApiV1ModelsResponses = {
+    /**
+     * OK
+     */
+    200: LlmapiModelsListResponse;
+};
+type GetApiV1ModelsResponse = GetApiV1ModelsResponses[keyof GetApiV1ModelsResponses];
+type PostApiV1ResponsesData = {
+    /**
+     * Response request
+     */
+    body: LlmapiResponseRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/responses';
+};
+type PostApiV1ResponsesErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostApiV1ResponsesError = PostApiV1ResponsesErrors[keyof PostApiV1ResponsesErrors];
+type PostApiV1ResponsesResponses = {
+    /**
+     * OK
+     */
+    200: LlmapiResponseResponse | string;
+};
+type PostApiV1ResponsesResponse = PostApiV1ResponsesResponses[keyof PostApiV1ResponsesResponses];
+type PostApiV1SearchData = {
+    /**
+     * Search request
+     */
+    body: LlmapiSearchRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/search';
+};
+type PostApiV1SearchErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostApiV1SearchError = PostApiV1SearchErrors[keyof PostApiV1SearchErrors];
+type PostApiV1SearchResponses = {
+    /**
+     * OK
+     */
+    200: LlmapiSearchResponse;
+};
+type PostApiV1SearchResponse = PostApiV1SearchResponses[keyof PostApiV1SearchResponses];
+type PostAuthOauthByProviderExchangeData = {
+    /**
+     * Exchange request
+     */
+    body: HandlersExchangeRequest;
+    path: {
+        /**
+         * OAuth provider (google-drive, dropbox)
+         */
+        provider: string;
+    };
+    query?: never;
+    url: '/auth/oauth/{provider}/exchange';
+};
+type PostAuthOauthByProviderExchangeErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostAuthOauthByProviderExchangeError = PostAuthOauthByProviderExchangeErrors[keyof PostAuthOauthByProviderExchangeErrors];
+type PostAuthOauthByProviderExchangeResponses = {
+    /**
+     * OK
+     */
+    200: HandlersTokenResponse;
+};
+type PostAuthOauthByProviderExchangeResponse = PostAuthOauthByProviderExchangeResponses[keyof PostAuthOauthByProviderExchangeResponses];
+type PostAuthOauthByProviderRefreshData = {
+    /**
+     * Refresh request
+     */
+    body: HandlersRefreshRequest;
+    path: {
+        /**
+         * OAuth provider (google-drive, dropbox)
+         */
+        provider: string;
+    };
+    query?: never;
+    url: '/auth/oauth/{provider}/refresh';
+};
+type PostAuthOauthByProviderRefreshErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostAuthOauthByProviderRefreshError = PostAuthOauthByProviderRefreshErrors[keyof PostAuthOauthByProviderRefreshErrors];
+type PostAuthOauthByProviderRefreshResponses = {
+    /**
+     * OK
+     */
+    200: HandlersTokenResponse;
+};
+type PostAuthOauthByProviderRefreshResponse = PostAuthOauthByProviderRefreshResponses[keyof PostAuthOauthByProviderRefreshResponses];
+type PostAuthOauthByProviderRevokeData = {
+    /**
+     * Revoke request
+     */
+    body: HandlersRevokeRequest;
+    path: {
+        /**
+         * OAuth provider (google-drive, dropbox)
+         */
+        provider: string;
+    };
+    query?: never;
+    url: '/auth/oauth/{provider}/revoke';
+};
+type PostAuthOauthByProviderRevokeErrors = {
+    /**
+     * Bad Request
+     */
+    400: ResponseErrorResponse;
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type PostAuthOauthByProviderRevokeError = PostAuthOauthByProviderRevokeErrors[keyof PostAuthOauthByProviderRevokeErrors];
+type PostAuthOauthByProviderRevokeResponses = {
+    /**
+     * Empty object on success
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+type PostAuthOauthByProviderRevokeResponse = PostAuthOauthByProviderRevokeResponses[keyof PostAuthOauthByProviderRevokeResponses];
+type GetHealthData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/health';
+};
+type GetHealthErrors = {
+    /**
+     * Internal Server Error
+     */
+    500: ResponseErrorResponse;
+};
+type GetHealthError = GetHealthErrors[keyof GetHealthErrors];
+type GetHealthResponses = {
+    /**
+     * OK
+     */
+    200: HandlersHealthResponse;
+};
+type GetHealthResponse = GetHealthResponses[keyof GetHealthResponses];
+
+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, Options> = (error: Err, response: Res, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Options> = (options: Options) => void | Promise<void>;
+type ResInterceptor<Res, Options> = (response: Res, 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<Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Options>>;
+    request: Interceptors<ReqInterceptor<Options>>;
+    response: Interceptors<ResInterceptor<Res, Options>>;
+}
+
+interface Config<T extends ClientOptions = ClientOptions> 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;
+    /**
+     * 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';
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    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<ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    response: Response;
+}> : Promise<({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    response: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError>;
+type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<TData, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions<TData, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError>;
+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<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> = OmitKeys<RequestOptions<TResponse, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+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
+ *
+ * Generates a chat completion using the configured gateway. Supports streaming when stream=true.
+ */
+declare const postApiV1ChatCompletions: <ThrowOnError extends boolean = false>(options: Options<PostApiV1ChatCompletionsData, ThrowOnError>) => RequestResult<PostApiV1ChatCompletionsResponses, PostApiV1ChatCompletionsErrors, ThrowOnError>;
+/**
+ * Get configuration
+ *
+ * Returns public configuration including contract addresses and payment model
+ */
+declare const getApiV1Config: <ThrowOnError extends boolean = false>(options?: Options<GetApiV1ConfigData, ThrowOnError>) => RequestResult<GetApiV1ConfigResponses, GetApiV1ConfigErrors, ThrowOnError>;
+/**
+ * Get OpenAPI specification
+ *
+ * Returns the OpenAPI 3.1 specification for this API
+ */
+declare const getApiV1DocsSwaggerJson: <ThrowOnError extends boolean = false>(options?: Options<GetApiV1DocsSwaggerJsonData, ThrowOnError>) => RequestResult<GetApiV1DocsSwaggerJsonResponses, unknown, ThrowOnError>;
+/**
+ * Create embeddings
+ *
+ * Generates embeddings using the configured gateway.
+ */
+declare const postApiV1Embeddings: <ThrowOnError extends boolean = false>(options: Options<PostApiV1EmbeddingsData, ThrowOnError>) => RequestResult<PostApiV1EmbeddingsResponses, PostApiV1EmbeddingsErrors, ThrowOnError>;
+/**
+ * Generate images
+ *
+ * Generates images using the configured LLM gateway.
+ */
+declare const postApiV1ImagesGenerations: <ThrowOnError extends boolean = false>(options: Options<PostApiV1ImagesGenerationsData, ThrowOnError>) => RequestResult<PostApiV1ImagesGenerationsResponses, PostApiV1ImagesGenerationsErrors, ThrowOnError>;
+/**
+ * List available models
+ *
+ * Returns a list of all available models from the configured gateway with optional filters. Models include modality information indicating their capabilities (e.g., llm, embedding, vision, image, audio, reasoning, code, reranker, multimodal, video).
+ */
+declare const getApiV1Models: <ThrowOnError extends boolean = false>(options?: Options<GetApiV1ModelsData, ThrowOnError>) => RequestResult<GetApiV1ModelsResponses, GetApiV1ModelsErrors, ThrowOnError>;
+/**
+ * Create response
+ *
+ * Generates a response using the Responses API format. Supports streaming when stream=true.
+ */
+declare const postApiV1Responses: <ThrowOnError extends boolean = false>(options: Options<PostApiV1ResponsesData, ThrowOnError>) => RequestResult<PostApiV1ResponsesResponses, PostApiV1ResponsesErrors, ThrowOnError>;
+/**
+ * Create search
+ *
+ * Returns a list of ranked search results
+ */
+declare const postApiV1Search: <ThrowOnError extends boolean = false>(options: Options<PostApiV1SearchData, ThrowOnError>) => RequestResult<PostApiV1SearchResponses, PostApiV1SearchErrors, ThrowOnError>;
+/**
+ * Exchange authorization code for tokens
+ *
+ * Exchanges an OAuth authorization code for access and refresh tokens
+ */
+declare const postAuthOauthByProviderExchange: <ThrowOnError extends boolean = false>(options: Options<PostAuthOauthByProviderExchangeData, ThrowOnError>) => RequestResult<PostAuthOauthByProviderExchangeResponses, PostAuthOauthByProviderExchangeErrors, ThrowOnError>;
+/**
+ * Refresh access token
+ *
+ * Refreshes an expired access token using a refresh token
+ */
+declare const postAuthOauthByProviderRefresh: <ThrowOnError extends boolean = false>(options: Options<PostAuthOauthByProviderRefreshData, ThrowOnError>) => RequestResult<PostAuthOauthByProviderRefreshResponses, PostAuthOauthByProviderRefreshErrors, ThrowOnError>;
+/**
+ * Revoke OAuth token
+ *
+ * Revokes an OAuth access or refresh token
+ */
+declare const postAuthOauthByProviderRevoke: <ThrowOnError extends boolean = false>(options: Options<PostAuthOauthByProviderRevokeData, ThrowOnError>) => RequestResult<PostAuthOauthByProviderRevokeResponses, PostAuthOauthByProviderRevokeErrors, ThrowOnError>;
+/**
+ * Health check
+ *
+ * Returns the current health status of the service.
+ */
+declare const getHealth: <ThrowOnError extends boolean = false>(options?: Options<GetHealthData, ThrowOnError>) => RequestResult<GetHealthResponses, GetHealthErrors, ThrowOnError>;
+
+export { type ClientOptions$1 as ClientOptions, type GetApiV1ConfigData, type GetApiV1ConfigError, type GetApiV1ConfigErrors, type GetApiV1ConfigResponse, type GetApiV1ConfigResponses, type GetApiV1DocsSwaggerJsonData, type GetApiV1DocsSwaggerJsonResponse, type GetApiV1DocsSwaggerJsonResponses, type GetApiV1ModelsData, type GetApiV1ModelsError, type GetApiV1ModelsErrors, type GetApiV1ModelsResponse, type GetApiV1ModelsResponses, type GetHealthData, type GetHealthError, type GetHealthErrors, type GetHealthResponse, type GetHealthResponses, type HandlersConfigResponse, type HandlersExchangeRequest, type HandlersHealthResponse, type HandlersRefreshRequest, type HandlersRevokeRequest, type HandlersTokenResponse, type LlmapiChatCompletionExtraFields, type LlmapiChatCompletionRequest, type LlmapiChatCompletionResponse, type LlmapiChatCompletionUsage, type LlmapiChoice, type LlmapiEmbeddingData, type LlmapiEmbeddingExtraFields, type LlmapiEmbeddingRequest, type LlmapiEmbeddingResponse, type LlmapiEmbeddingUsage, type LlmapiImageGenerationExtraFields, type LlmapiImageGenerationImage, type LlmapiImageGenerationRequest, type LlmapiImageGenerationResponse, type LlmapiImageGenerationUsage, type LlmapiMessage, type LlmapiMessageContentImage, type LlmapiMessageContentPart, type LlmapiModel, type LlmapiModelArchitecture, type LlmapiModelPerRequestLimits, type LlmapiModelPricing, type LlmapiModelTopProvider, type LlmapiModelsListExtraFields, type LlmapiModelsListResponse, type LlmapiResponseExtraFields, type LlmapiResponseOutputContent, type LlmapiResponseOutputItem, type LlmapiResponseReasoning, type LlmapiResponseRequest, type LlmapiResponseResponse, type LlmapiResponseUsage, type LlmapiRole, type LlmapiSearchExtraFields, type LlmapiSearchRequest, type LlmapiSearchResponse, type LlmapiSearchResult, type LlmapiSearchUsage, type LlmapiThinkingOptions, type LlmapiTool, type LlmapiToolCall, type LlmapiToolCallFunction, type LlmapiToolFunction, type Options, type PostApiV1ChatCompletionsData, type PostApiV1ChatCompletionsError, type PostApiV1ChatCompletionsErrors, type PostApiV1ChatCompletionsResponse, type PostApiV1ChatCompletionsResponses, type PostApiV1EmbeddingsData, type PostApiV1EmbeddingsError, type PostApiV1EmbeddingsErrors, type PostApiV1EmbeddingsResponse, type PostApiV1EmbeddingsResponses, type PostApiV1ImagesGenerationsData, type PostApiV1ImagesGenerationsError, type PostApiV1ImagesGenerationsErrors, type PostApiV1ImagesGenerationsResponse, type PostApiV1ImagesGenerationsResponses, type PostApiV1ResponsesData, type PostApiV1ResponsesError, type PostApiV1ResponsesErrors, type PostApiV1ResponsesResponse, type PostApiV1ResponsesResponses, type PostApiV1SearchData, type PostApiV1SearchError, type PostApiV1SearchErrors, type PostApiV1SearchResponse, type PostApiV1SearchResponses, type PostAuthOauthByProviderExchangeData, type PostAuthOauthByProviderExchangeError, type PostAuthOauthByProviderExchangeErrors, type PostAuthOauthByProviderExchangeResponse, type PostAuthOauthByProviderExchangeResponses, type PostAuthOauthByProviderRefreshData, type PostAuthOauthByProviderRefreshError, type PostAuthOauthByProviderRefreshErrors, type PostAuthOauthByProviderRefreshResponse, type PostAuthOauthByProviderRefreshResponses, type PostAuthOauthByProviderRevokeData, type PostAuthOauthByProviderRevokeError, type PostAuthOauthByProviderRevokeErrors, type PostAuthOauthByProviderRevokeResponse, type PostAuthOauthByProviderRevokeResponses, type ResponseErrorResponse, getApiV1Config, getApiV1DocsSwaggerJson, getApiV1Models, getHealth, postApiV1ChatCompletions, postApiV1Embeddings, postApiV1ImagesGenerations, postApiV1Responses, postApiV1Search, postAuthOauthByProviderExchange, postAuthOauthByProviderRefresh, postAuthOauthByProviderRevoke };