objectiveai 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1238 @@
+import OpenAI from "openai";
+import { Stream } from "openai/streaming";
+export declare namespace Chat {
+    namespace Completions {
+        namespace Request {
+            interface ChatCompletionCreateParamsBase {
+                messages: Message[];
+                model: string;
+                frequency_penalty?: number | null;
+                logit_bias?: Record<string, number> | null;
+                logprobs?: boolean | null;
+                max_completion_tokens?: number | null;
+                modalities?: string[] | null;
+                n?: number | null;
+                parallel_tool_calls?: boolean | null;
+                prediction?: Prediction | null;
+                presence_penalty?: number | null;
+                reasoning_effort?: ReasoningEffort | null;
+                response_format?: ResponseFormat | null;
+                seed?: number | null;
+                service_tier?: ServiceTier | null;
+                stop?: Stop | null;
+                stream_options?: StreamOptions | null;
+                temperature?: number | null;
+                tool_choice?: ToolChoice | null;
+                tools?: Tool[] | null;
+                top_logprobs?: number | null;
+                top_p?: number | null;
+                web_search_options?: WebSearchOptions | null;
+                max_tokens?: number | null;
+                min_p?: number | null;
+                plugins?: Plugin[] | null;
+                provider?: ProviderPreferences | null;
+                reasoning?: Reasoning | null;
+                repetition_penalty?: number | null;
+                top_a?: number | null;
+                top_k?: number | null;
+                usage?: Usage | null;
+                verbosity?: Verbosity | null;
+                models?: string[] | null;
+            }
+            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+                stream: true;
+            }
+            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+                stream?: false | null;
+            }
+            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
+            type ServiceTier = "auto" | "default" | "flex";
+            type Stop = string | string[];
+            interface Prediction {
+                content: Prediction.Content;
+                type: "content";
+            }
+            namespace Prediction {
+                type Content = string | Content.Part[];
+                namespace Content {
+                    interface Part {
+                        text: string;
+                        type: "text";
+                    }
+                }
+            }
+            type ReasoningEffort = "low" | "medium" | "high";
+            type ResponseFormat = ResponseFormat.Text | ResponseFormat.JsonObject | ResponseFormat.JsonSchema;
+            namespace ResponseFormat {
+                interface Text {
+                    type: "text";
+                }
+                interface JsonObject {
+                    type: "json_object";
+                }
+                interface JsonSchema {
+                    type: "json_schema";
+                    json_schema: JsonSchema.JsonSchema;
+                }
+                namespace JsonSchema {
+                    interface JsonSchema {
+                        name: string;
+                        description?: string | null;
+                        schema?: JsonValue;
+                        strict?: boolean | null;
+                    }
+                }
+            }
+            interface StreamOptions {
+                include_usage?: boolean;
+            }
+            type ToolChoice = "none" | "auto" | "required" | ToolChoice.Function;
+            namespace ToolChoice {
+                interface Function {
+                    type: "function";
+                    function: Function.Function;
+                }
+                namespace Function {
+                    interface Function {
+                        name: string;
+                    }
+                }
+            }
+            interface WebSearchOptions {
+                search_context_size?: WebSearchOptions.SearchContextSize | null;
+                user_location?: WebSearchOptions.UserLocation | null;
+            }
+            namespace WebSearchOptions {
+                type SearchContextSize = "low" | "medium" | "high";
+                interface UserLocation {
+                    approximate: UserLocation.Approximate;
+                    type: "approximate";
+                }
+                namespace UserLocation {
+                    interface Approximate {
+                        city?: string | null;
+                        country?: string | null;
+                        region?: string | null;
+                        timezone?: string | null;
+                    }
+                }
+            }
+            type Tool = Tool.Function;
+            namespace Tool {
+                interface Function {
+                    function: Function.Definition;
+                    type: "function";
+                }
+                namespace Function {
+                    interface Definition {
+                        name: string;
+                        description?: string | null;
+                        parameters?: JsonValue;
+                        strict?: boolean | null;
+                    }
+                }
+            }
+            type Message = Message.Developer | Message.System | Message.User | Message.Assistant | Message.Tool;
+            namespace Message {
+                interface Developer {
+                    role: "developer";
+                    content: Developer.Content;
+                    name?: string;
+                }
+                namespace Developer {
+                    type Content = string | Content.Part[];
+                    namespace Content {
+                        interface Part {
+                            text: string;
+                            type: "text";
+                        }
+                    }
+                }
+                interface System {
+                    role: "system";
+                    content: System.Content;
+                    name?: string;
+                }
+                namespace System {
+                    type Content = string | Content.Part[];
+                    namespace Content {
+                        interface Part {
+                            text: string;
+                            type: "text";
+                        }
+                    }
+                }
+                interface User {
+                    role: "user";
+                    content: User.Content;
+                    name?: string;
+                }
+                namespace User {
+                    type Content = string | Content.Part[];
+                    namespace Content {
+                        type Part = Part.Text | Part.ImageUrl | Part.InputAudio | Part.File;
+                        namespace Part {
+                            interface Text {
+                                text: string;
+                                type: "text";
+                            }
+                            interface ImageUrl {
+                                image_url: ImageUrl.Definition;
+                                type: "image_url";
+                            }
+                            namespace ImageUrl {
+                                interface Definition {
+                                    url: string;
+                                    detail?: ImageUrl.Detail | null;
+                                }
+                                type Detail = "auto" | "low" | "high";
+                            }
+                            interface InputAudio {
+                                input_audio: InputAudio.Definition;
+                                type: "input_audio";
+                            }
+                            namespace InputAudio {
+                                interface Definition {
+                                    data: string;
+                                    format: Format;
+                                }
+                                type Format = "wav" | "mp3";
+                            }
+                            interface File {
+                                file: File.Definition;
+                                type: "file";
+                            }
+                            namespace File {
+                                interface Definition {
+                                    file_data?: string | null;
+                                    file_id?: string | null;
+                                    filename?: string | null;
+                                }
+                            }
+                        }
+                    }
+                }
+                interface Assistant {
+                    role: "assistant";
+                    content?: Assistant.Content | null;
+                    name?: string | null;
+                    refusal?: string | null;
+                    tool_calls?: Assistant.ToolCall[] | null;
+                }
+                namespace Assistant {
+                    type Content = string | Content.Part[];
+                    namespace Content {
+                        type Part = Part.Text | Part.Refusal;
+                        namespace Part {
+                            interface Text {
+                                text: string;
+                                type: "text";
+                            }
+                            interface Refusal {
+                                refusal: string;
+                                type: "refusal";
+                            }
+                        }
+                    }
+                    type ToolCall = ToolCall.Function;
+                    namespace ToolCall {
+                        interface Function {
+                            id: string;
+                            function: Function.Definition;
+                            type: "function";
+                        }
+                        namespace Function {
+                            interface Definition {
+                                name: string;
+                                arguments: string;
+                            }
+                        }
+                    }
+                }
+                interface Tool {
+                    role: "tool";
+                    content?: Tool.Content | null;
+                    tool_call_id: string;
+                }
+                namespace Tool {
+                    type Content = string | Content.Part[];
+                    namespace Content {
+                        interface Part {
+                            text: string;
+                            type: "text";
+                        }
+                    }
+                }
+            }
+            interface ProviderPreferences {
+                order?: string[] | null;
+                allow_fallbacks?: boolean | null;
+                require_parameters?: boolean | null;
+                data_collection?: ProviderPreferences.DataCollection | null;
+                only?: string[] | null;
+                ignore?: string[] | null;
+                quantizations?: string[] | null;
+                sort?: string | null;
+            }
+            namespace ProviderPreferences {
+                type DataCollection = "allow" | "deny";
+            }
+            interface Plugin {
+                id: string;
+                [key: string]: JsonValue;
+            }
+            interface Reasoning {
+                max_tokens?: number | null;
+                effort?: ReasoningEffort | null;
+                enabled?: boolean | null;
+            }
+            interface Usage {
+                include: boolean;
+            }
+            type Verbosity = "low" | "medium" | "high";
+        }
+        namespace Response {
+            namespace Streaming {
+                interface ChatCompletionChunk {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion.chunk";
+                    service_tier?: ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Usage;
+                    provider?: string;
+                }
+                namespace ChatCompletionChunk {
+                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
+                }
+                interface Choice {
+                    delta: Delta;
+                    finish_reason: FinishReason | null;
+                    index: number;
+                    logprobs?: Logprobs;
+                }
+                namespace Choice {
+                    function merged(a: Choice, b: Choice): [Choice, boolean];
+                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
+                }
+                interface Delta {
+                    content?: string;
+                    refusal?: string;
+                    role?: Role;
+                    tool_calls?: ToolCall[];
+                    reasoning?: string;
+                    images?: Image[];
+                }
+                namespace Delta {
+                    function merged(a: Delta, b: Delta): [Delta, boolean];
+                }
+                type ToolCall = ToolCall.Function;
+                namespace ToolCall {
+                    function merged(a: ToolCall, b: ToolCall): [ToolCall, boolean];
+                    function mergedList(a: ToolCall[], b: ToolCall[]): [ToolCall[], boolean];
+                    interface Function {
+                        index: number;
+                        id?: string;
+                        function?: Function.Definition;
+                        type?: "function";
+                    }
+                    namespace Function {
+                        function merged(a: Function, b: Function): [Function, boolean];
+                        interface Definition {
+                            name?: string;
+                            arguments?: string;
+                        }
+                        namespace Definition {
+                            function merged(a: Definition, b: Definition): [Definition, boolean];
+                        }
+                    }
+                }
+            }
+            namespace Unary {
+                interface ChatCompletion {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion";
+                    service_tier?: ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Usage;
+                    provider?: string;
+                }
+                interface Choice {
+                    message: Message;
+                    finish_reason: FinishReason;
+                    index: number;
+                    logprobs: Logprobs | null;
+                }
+                interface Message {
+                    content: string | null;
+                    refusal: string | null;
+                    role: Role;
+                    annotations?: Annotation[];
+                    audio?: Audio;
+                    tool_calls?: ToolCall[];
+                    reasoning?: string;
+                    images?: Image[];
+                }
+                type Annotation = Annotation.UrlCitation;
+                namespace Annotation {
+                    interface UrlCitation {
+                        url_citation: UrlCitation.Definition;
+                    }
+                    namespace UrlCitation {
+                        interface Definition {
+                            end_index: number;
+                            start_index: number;
+                            title: string;
+                            url: string;
+                        }
+                    }
+                }
+                interface Audio {
+                    id: string;
+                    data: string;
+                    expires_at: number;
+                    transcript: string;
+                }
+                type ToolCall = ToolCall.Function;
+                namespace ToolCall {
+                    interface Function {
+                        id: string;
+                        function: Function.Definition;
+                        type: "function";
+                    }
+                    namespace Function {
+                        interface Definition {
+                            name: string;
+                            arguments: string;
+                        }
+                    }
+                }
+            }
+            type ServiceTier = "auto" | "default" | "flex";
+            type FinishReason = "stop" | "length" | "tool_calls" | "content_filter" | "error";
+            interface Usage {
+                completion_tokens: number;
+                prompt_tokens: number;
+                total_tokens: number;
+                completion_tokens_details?: Usage.CompletionTokensDetails;
+                prompt_tokens_details?: Usage.PromptTokensDetails;
+                cost?: number;
+                cost_details?: Usage.CostDetails;
+            }
+            namespace Usage {
+                function merged(a: Usage, b: Usage): [Usage, boolean];
+                interface CompletionTokensDetails {
+                    accepted_prediction_tokens?: number;
+                    audio_tokens?: number;
+                    reasoning_tokens?: number;
+                    rejected_prediction_tokens?: number;
+                }
+                namespace CompletionTokensDetails {
+                    function merged(a: CompletionTokensDetails, b: CompletionTokensDetails): [CompletionTokensDetails, boolean];
+                }
+                interface PromptTokensDetails {
+                    audio_tokens?: number;
+                    cached_tokens?: number;
+                }
+                namespace PromptTokensDetails {
+                    function merged(a: PromptTokensDetails, b: PromptTokensDetails): [PromptTokensDetails, boolean];
+                }
+                interface CostDetails {
+                    upstream_inference_cost?: number;
+                    upstream_upstream_inference_cost?: number;
+                }
+                namespace CostDetails {
+                    function merged(a: CostDetails, b: CostDetails): [CostDetails, boolean];
+                }
+            }
+            interface Logprobs {
+                content: Logprobs.Logprob[];
+                refusal: Logprobs.Logprob[];
+            }
+            namespace Logprobs {
+                function merged(a: Logprobs, b: Logprobs): [Logprobs, boolean];
+                interface Logprob {
+                    token: string;
+                    bytes: number[];
+                    logprob: number;
+                    top_logprobs: Logprob.TopLogprob[];
+                }
+                namespace Logprob {
+                    function mergedList(a: Logprob[], b: Logprob[]): [Logprob[], boolean];
+                    interface TopLogprob {
+                        token: string;
+                        bytes: number[] | null;
+                        logprob: number | null;
+                    }
+                }
+            }
+            type Role = "assistant";
+            type Image = Image.ImageUrl;
+            namespace Image {
+                function mergedList(a: Image[], b: Image[]): [Image[], boolean];
+                interface ImageUrl {
+                    type: "image_url";
+                    image_url: {
+                        url: string;
+                    };
+                }
+            }
+        }
+        interface ListOptions {
+            count?: number | null;
+            offset?: number | null;
+        }
+        interface ListItem {
+            id: string;
+            created: string;
+        }
+        function list(openai: OpenAI, listOptions?: ListOptions, options?: OpenAI.RequestOptions): Promise<{
+            data: ListItem[];
+        }>;
+        function publish(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
+        function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
+            request: Request.ChatCompletionCreateParams;
+            response: Response.Unary.ChatCompletion;
+        }>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
+    }
+}
+export declare namespace Query {
+    namespace Completions {
+        namespace Request {
+            interface ChatCompletionCreateParamsBase {
+                messages: Chat.Completions.Request.Message[];
+                model: Model;
+                logprobs?: boolean | null;
+                n?: number | null;
+                prediction?: Chat.Completions.Request.Prediction | null;
+                response_format?: Chat.Completions.Request.ResponseFormat | null;
+                seed?: number | null;
+                service_tier?: Chat.Completions.Request.ServiceTier | null;
+                stream_options?: Chat.Completions.Request.StreamOptions | null;
+                tools?: Chat.Completions.Request.Tool[] | null;
+                top_logprobs?: number | null;
+                usage?: Chat.Completions.Request.Usage | null;
+                embeddings?: string | null;
+            }
+            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+                stream: true;
+            }
+            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+                stream?: false | null;
+            }
+            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
+            type Model = string | QueryModelBase;
+        }
+        namespace Response {
+            namespace Streaming {
+                interface ChatCompletionChunk {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion.chunk";
+                    service_tier?: Chat.Completions.Response.ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Chat.Completions.Response.Usage;
+                    training_table_data?: TrainingTableData;
+                }
+                namespace ChatCompletionChunk {
+                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
+                }
+                interface Choice {
+                    delta: Chat.Completions.Response.Streaming.Delta;
+                    finish_reason: Chat.Completions.Response.FinishReason | null;
+                    index: number;
+                    logprobs?: Chat.Completions.Response.Logprobs;
+                    generate_id?: string;
+                    confidence_id?: ConfidenceId;
+                    confidence_weight?: number;
+                    confidence?: number;
+                    embedding?: EmbeddingsResponse | ObjectiveAIError;
+                    error?: ObjectiveAIError;
+                    model: string;
+                    model_index: number | null;
+                    completion_metadata: CompletionMetadata;
+                }
+                namespace Choice {
+                    function merged(a: Choice, b: Choice): [Choice, boolean];
+                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
+                }
+            }
+            namespace Unary {
+                interface ChatCompletion {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion";
+                    service_tier?: Chat.Completions.Response.ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Chat.Completions.Response.Usage;
+                    training_table_data?: TrainingTableData;
+                }
+                interface Choice {
+                    message: Chat.Completions.Response.Unary.Message;
+                    finish_reason: Chat.Completions.Response.FinishReason;
+                    index: number;
+                    logprobs: Chat.Completions.Response.Logprobs | null;
+                    generate_id: string | null;
+                    confidence_id: ConfidenceId | null;
+                    confidence_weight: number | null;
+                    confidence: number | null;
+                    embedding?: EmbeddingsResponse | ObjectiveAIError;
+                    error?: ObjectiveAIError;
+                    model: string;
+                    model_index: number | null;
+                    completion_metadata: CompletionMetadata;
+                }
+            }
+            interface TrainingTableData {
+                response_format_hash: string;
+                embeddings_response: EmbeddingsResponse;
+            }
+            interface EmbeddingsResponse {
+                data: EmbeddingsResponse.Embedding[];
+                model: string;
+                object: "list";
+                usage?: Chat.Completions.Response.Usage;
+            }
+            namespace EmbeddingsResponse {
+                interface Embedding {
+                    embedding: number[];
+                    index: number;
+                    object: "embedding";
+                }
+            }
+            interface CompletionMetadata {
+                id: string;
+                created: number;
+                model: string;
+                service_tier?: Chat.Completions.Response.ServiceTier;
+                system_fingerprint?: string;
+                usage?: Chat.Completions.Response.Usage;
+                provider?: string;
+            }
+            namespace CompletionMetadata {
+                function merged(a: CompletionMetadata, b: CompletionMetadata): [CompletionMetadata, boolean];
+            }
+            type ConfidenceId = string | Record<string, number>;
+        }
+        function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+            data: Chat.Completions.ListItem[];
+        }>;
+        function publish(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
+        function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
+            request: Request.ChatCompletionCreateParams;
+            response: Response.Unary.ChatCompletion;
+            correct_confidence_id?: string;
+        }>;
+        function trainingTableMark(openai: OpenAI, id: string, correctConfidenceId: string, options?: OpenAI.RequestOptions): Promise<void>;
+        function trainingTableUnmark(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
+    }
+}
+export declare namespace QueryTool {
+    namespace Completions {
+        namespace Request {
+            interface ChatCompletionCreateParamsBase {
+                messages: Chat.Completions.Request.Message[];
+                model: Query.Completions.Request.Model;
+                logprobs?: boolean | null;
+                n?: number | null;
+                prediction?: Chat.Completions.Request.Prediction | null;
+                response_format: ResponseFormat;
+                seed?: number | null;
+                service_tier?: Chat.Completions.Request.ServiceTier | null;
+                stream_options?: Chat.Completions.Request.StreamOptions | null;
+                tools?: Chat.Completions.Request.Tool[] | null;
+                top_logprobs?: number | null;
+                usage?: Chat.Completions.Request.Usage | null;
+                embeddings?: string | null;
+                select_deterministic?: boolean | null;
+            }
+            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+                stream: true;
+            }
+            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+                stream?: false | null;
+            }
+            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
+            type ResponseFormat = ResponseFormat.Simple | ResponseFormat.NumberQuery | ResponseFormat.MultipleChoiceQuery | ResponseFormat.MultipleChoiceOptionsQuery | ResponseFormat.WeightedAverageChoiceQuery;
+            namespace ResponseFormat {
+                type Simple = {
+                    tool: "simple_query";
+                    top?: number | null;
+                    select_deterministic?: boolean | null;
+                } | ({
+                    tool: "simple_query";
+                    top?: number | null;
+                    select_deterministic?: boolean | null;
+                } & Chat.Completions.Request.ResponseFormat);
+                interface NumberQuery {
+                    tool: "number_query";
+                }
+                interface MultipleChoiceQuery {
+                    tool: "multiple_choice_query";
+                    choices: string[];
+                }
+                interface MultipleChoiceOptionsQuery {
+                    tool: "multiple_choice_options_query";
+                    min_items: number;
+                    max_items: number;
+                }
+                type WeightedAverageChoiceQuery = {
+                    tool: "weighted_average_choice_query";
+                    embeddings_model: string;
+                    select_deterministic?: boolean | null;
+                } | ({
+                    tool: "weighted_average_choice_query";
+                    embeddings_model: string;
+                    select_deterministic?: boolean | null;
+                } & Chat.Completions.Request.ResponseFormat);
+            }
+        }
+        namespace Response {
+            namespace Streaming {
+                interface ChatCompletionChunk {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: Model;
+                    object: "chat.completion.chunk";
+                    service_tier?: Chat.Completions.Response.ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Chat.Completions.Response.Usage;
+                }
+                namespace ChatCompletionChunk {
+                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
+                }
+                interface Choice {
+                    delta: Delta;
+                    finish_reason: Chat.Completions.Response.FinishReason | null;
+                    index: number;
+                    logprobs?: Chat.Completions.Response.Logprobs;
+                }
+                namespace Choice {
+                    function merged(a: Choice, b: Choice): [Choice, boolean];
+                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
+                }
+                interface Delta {
+                    content?: string;
+                    refusal?: string;
+                    role?: Chat.Completions.Response.Role;
+                    tool_calls?: Chat.Completions.Response.Streaming.ToolCall[];
+                    reasoning?: Reasoning;
+                }
+                namespace Delta {
+                    function merged(a: Delta, b: Delta): [Delta, boolean];
+                }
+                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
+                namespace Reasoning {
+                    function merged(a: Reasoning, b: Reasoning): [Reasoning, boolean];
+                }
+                type ReasoningCompletion = ReasoningCompletion.QueryCompletion | ReasoningCompletion.ChatCompletion;
+                namespace ReasoningCompletion {
+                    type QueryCompletion = {
+                        index: number;
+                        type: "query";
+                        error?: ObjectiveAIError;
+                    } & Query.Completions.Response.Streaming.ChatCompletionChunk;
+                    namespace QueryCompletion {
+                        function merged(a: QueryCompletion, b: QueryCompletion): [QueryCompletion, boolean];
+                    }
+                    type ChatCompletion = {
+                        index: number;
+                        type: "chat";
+                        error?: ObjectiveAIError;
+                    } & Chat.Completions.Response.Streaming.ChatCompletionChunk;
+                    namespace ChatCompletion {
+                        function merged(a: ChatCompletion, b: ChatCompletion): [ChatCompletion, boolean];
+                    }
+                }
+            }
+            namespace Unary {
+                interface ChatCompletion {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: Model;
+                    object: "chat.completion";
+                    service_tier?: Chat.Completions.Response.ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Chat.Completions.Response.Usage;
+                }
+                interface Choice {
+                    message: Message;
+                    finish_reason: Chat.Completions.Response.FinishReason;
+                    index: number;
+                    logprobs: Chat.Completions.Response.Logprobs | null;
+                }
+                interface Message {
+                    content: string | null;
+                    refusal: string | null;
+                    role: Chat.Completions.Response.Role;
+                    annotations?: Chat.Completions.Response.Unary.Annotation[];
+                    audio?: Chat.Completions.Response.Unary.Audio;
+                    tool_calls?: Chat.Completions.Response.Unary.ToolCall[];
+                    reasoning?: Reasoning;
+                }
+                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
+                type ReasoningCompletion = ReasoningCompletion.QueryCompletion | ReasoningCompletion.ChatCompletion;
+                namespace ReasoningCompletion {
+                    type QueryCompletion = {
+                        index: number;
+                        type: "query";
+                        error?: ObjectiveAIError;
+                    } & Query.Completions.Response.Unary.ChatCompletion;
+                    type ChatCompletion = {
+                        index: number;
+                        type: "chat";
+                        error?: ObjectiveAIError;
+                    } & Chat.Completions.Response.Unary.ChatCompletion;
+                }
+            }
+            type Model = "simple_query" | "number_query" | "multiple_choice_query" | "multiple_choice_options_query" | "weighted_average_choice_query";
+        }
+        function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+            data: Chat.Completions.ListItem[];
+        }>;
+        function publish(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
+        function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
+            request: Request.ChatCompletionCreateParams;
+            response: Response.Unary.ChatCompletion;
+        }>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
+    }
+}
+export declare namespace QueryChat {
+    namespace Completions {
+        namespace Request {
+            interface ChatCompletionCreateParamsBase {
+                messages: Chat.Completions.Request.Message[];
+                model: string;
+                frequency_penalty?: number | null;
+                logit_bias?: Record<string, number> | null;
+                logprobs?: boolean | null;
+                max_completion_tokens?: number | null;
+                modalities?: string[] | null;
+                parallel_tool_calls?: boolean | null;
+                prediction?: Chat.Completions.Request.Prediction | null;
+                presence_penalty?: number | null;
+                reasoning_effort?: Chat.Completions.Request.ReasoningEffort | null;
+                response_format?: Chat.Completions.Request.ResponseFormat | null;
+                seed?: number | null;
+                service_tier?: Chat.Completions.Request.ServiceTier | null;
+                stop?: Chat.Completions.Request.Stop | null;
+                stream_options?: Chat.Completions.Request.StreamOptions | null;
+                temperature?: number | null;
+                top_logprobs?: number | null;
+                top_p?: number | null;
+                max_tokens?: number | null;
+                min_p?: number | null;
+                provider?: Chat.Completions.Request.ProviderPreferences | null;
+                reasoning?: Chat.Completions.Request.Reasoning | null;
+                repetition_penalty?: number | null;
+                top_a?: number | null;
+                top_k?: number | null;
+                usage?: Chat.Completions.Request.Usage | null;
+                verbosity?: Chat.Completions.Request.Verbosity | null;
+                models?: string[] | null;
+                training_table_name?: string | null;
+                simple_query: QueryToolParams;
+                multiple_choice_query: QueryToolParams;
+                multiple_choice_options_query: QueryToolParams;
+            }
+            interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+                stream: true;
+            }
+            interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+                stream?: false | null;
+            }
+            type ChatCompletionCreateParams = ChatCompletionCreateParamsStreaming | ChatCompletionCreateParamsNonStreaming;
+            interface QueryToolParams {
+                model: Query.Completions.Request.Model;
+                logprobs?: boolean | null;
+                n?: number | null;
+                prediction?: Chat.Completions.Request.Prediction | null;
+                seed?: number | null;
+                service_tier?: Chat.Completions.Request.ServiceTier | null;
+                tools?: Chat.Completions.Request.Tool[] | null;
+                top_logprobs?: number | null;
+                embeddings?: string | null;
+            }
+        }
+        namespace Response {
+            namespace Streaming {
+                interface ChatCompletionChunk {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion.chunk";
+                    service_tier?: Chat.Completions.Response.ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Chat.Completions.Response.Usage;
+                }
+                namespace ChatCompletionChunk {
+                    function merged(a: ChatCompletionChunk, b: ChatCompletionChunk): [ChatCompletionChunk, boolean];
+                }
+                interface Choice {
+                    delta: Delta;
+                    finish_reason: Chat.Completions.Response.FinishReason | null;
+                    index: number;
+                    logprobs?: Chat.Completions.Response.Logprobs;
+                }
+                namespace Choice {
+                    function merged(a: Choice, b: Choice): [Choice, boolean];
+                    function mergedList(a: Choice[], b: Choice[]): [Choice[], boolean];
+                }
+                interface Delta {
+                    content?: string;
+                    refusal?: string;
+                    role?: Chat.Completions.Response.Role;
+                    tool_calls?: Chat.Completions.Response.Streaming.ToolCall[];
+                    images?: Chat.Completions.Response.Image[];
+                    reasoning?: Reasoning;
+                }
+                namespace Delta {
+                    function merged(a: Delta, b: Delta): [Delta, boolean];
+                }
+                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
+                namespace Reasoning {
+                    function merged(a: Reasoning, b: Reasoning): [Reasoning, boolean];
+                }
+                type ReasoningCompletion = ReasoningCompletion.QueryToolCompletion | ReasoningCompletion.ChatCompletion;
+                namespace ReasoningCompletion {
+                    type QueryToolCompletion = {
+                        index: number;
+                        type: "query_tool";
+                        tool_call_id: string;
+                        error?: ObjectiveAIError;
+                    } & QueryTool.Completions.Response.Streaming.ChatCompletionChunk;
+                    namespace QueryToolCompletion {
+                        function merged(a: QueryToolCompletion, b: QueryToolCompletion): [QueryToolCompletion, boolean];
+                    }
+                    type ChatCompletion = {
+                        index: number;
+                        type: "chat";
+                        error?: ObjectiveAIError;
+                    } & Chat.Completions.Response.Streaming.ChatCompletionChunk;
+                    namespace ChatCompletion {
+                        function merged(a: ChatCompletion, b: ChatCompletion): [ChatCompletion, boolean];
+                    }
+                }
+            }
+            namespace Unary {
+                interface ChatCompletion {
+                    id: string;
+                    choices: Choice[];
+                    created: number;
+                    model: string;
+                    object: "chat.completion";
+                    service_tier?: Chat.Completions.Response.ServiceTier;
+                    system_fingerprint?: string;
+                    usage?: Chat.Completions.Response.Usage;
+                }
+                interface Choice {
+                    message: Message;
+                    finish_reason: Chat.Completions.Response.FinishReason;
+                    index: number;
+                    logprobs: Chat.Completions.Response.Logprobs | null;
+                }
+                interface Message {
+                    content: string | null;
+                    refusal: string | null;
+                    role: Chat.Completions.Response.Role;
+                    annotations?: Chat.Completions.Response.Unary.Annotation[];
+                    audio?: Chat.Completions.Response.Unary.Audio;
+                    tool_calls?: Chat.Completions.Response.Unary.ToolCall[];
+                    images?: Chat.Completions.Response.Image[];
+                    reasoning?: Reasoning;
+                }
+                type Reasoning = ReasoningCompletion | ReasoningCompletion[];
+                type ReasoningCompletion = ReasoningCompletion.QueryToolCompletion | ReasoningCompletion.ChatCompletion;
+                namespace ReasoningCompletion {
+                    type QueryToolCompletion = {
+                        index: number;
+                        type: "query_tool";
+                        tool_call_id: string;
+                        error?: ObjectiveAIError;
+                    } & QueryTool.Completions.Response.Unary.ChatCompletion;
+                    type ChatCompletion = {
+                        index: number;
+                        type: "chat";
+                        error?: ObjectiveAIError;
+                    } & Chat.Completions.Response.Unary.ChatCompletion;
+                }
+            }
+        }
+        function list(openai: OpenAI, listOptions?: Chat.Completions.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+            data: Chat.Completions.ListItem[];
+        }>;
+        function publish(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<void>;
+        function retrieve(openai: OpenAI, id: string, options?: OpenAI.RequestOptions): Promise<{
+            request: Request.ChatCompletionCreateParams;
+            response: Response.Unary.ChatCompletion;
+        }>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsStreaming, options?: OpenAI.RequestOptions): Promise<Stream<Response.Streaming.ChatCompletionChunk | ObjectiveAIError>>;
+        function create(openai: OpenAI, body: Request.ChatCompletionCreateParamsNonStreaming, options?: OpenAI.RequestOptions): Promise<Response.Unary.ChatCompletion>;
+    }
+}
+export declare namespace Models {
+    interface Model {
+        id: string;
+        name: string;
+        created: number;
+        description: string;
+        architecture: Architecture;
+        top_provider: TopProvider;
+        pricing: Pricing;
+        context_length?: number;
+        hugging_face_id?: string;
+        per_request_limits?: Record<string, unknown>;
+        supported_parameters?: string[];
+    }
+    interface ModelWithProviders {
+        id: string;
+        name: string;
+        created: number;
+        description: string;
+        architecture: Architecture;
+        endpoints: Provider[];
+    }
+    interface Architecture {
+        input_modalities: string[];
+        output_modalities: string[];
+        tokenizer: string;
+        instruct_type?: string;
+    }
+    interface TopProvider {
+        is_moderated: boolean;
+        context_length?: number;
+        max_completion_tokens?: number;
+    }
+    interface Pricing {
+        prompt: number;
+        completion: number;
+        image?: number;
+        request?: number;
+        input_cache_read?: number;
+        input_cache_write?: number;
+        web_search?: number;
+        internal_reasoning?: number;
+        discount?: number;
+    }
+    interface Provider {
+        name: string;
+        tag: string;
+        context_length?: number;
+        pricing: Pricing;
+        provider_name: string;
+        supported_parameters?: string[];
+        quantization?: string;
+        max_completion_tokens?: number;
+        max_prompt_tokens?: number;
+        status?: unknown;
+    }
+    interface ListOptions {
+        count?: number;
+        offset?: number;
+        me?: boolean;
+        sort?: "created" | "tokens" | "completion_tokens" | "prompt_tokens" | "cost" | "requests";
+        from?: string;
+        to?: string;
+    }
+    interface RetrieveOptionsBase {
+        me?: boolean | null;
+        from?: string | null;
+        to?: string | null;
+    }
+    interface RetrieveOptionsWithMetadata extends RetrieveOptionsBase {
+        metadata: true;
+    }
+    interface RetrieveOptionsWithoutMetadata extends RetrieveOptionsBase {
+        metadata?: false | null;
+    }
+    type RetrieveOptions = RetrieveOptionsWithMetadata | RetrieveOptionsWithoutMetadata;
+    function list(openai: OpenAI, listOptions?: ListOptions, options?: OpenAI.RequestOptions): Promise<{
+        data: Model[];
+    }>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptions, options?: OpenAI.RequestOptions): Promise<{
+        data: ModelWithProviders;
+    }>;
+}
+export declare namespace Auth {
+    interface ApiKey {
+        api_key: string;
+        created: string;
+        expires: string | null;
+        disabled: string | null;
+        name: string;
+        description: string | null;
+    }
+    interface ApiKeyWithCost extends ApiKey {
+        cost: number;
+    }
+    namespace ApiKey {
+        function list(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
+            data: ApiKeyWithCost[];
+        }>;
+        function create(openai: OpenAI, name: string, expires?: Date | null, description?: string | null, options?: OpenAI.RequestOptions): Promise<ApiKey>;
+        function remove(openai: OpenAI, key: string, options?: OpenAI.RequestOptions): Promise<ApiKey>;
+    }
+    interface OpenRouterApiKey {
+        api_key: string;
+    }
+    namespace OpenRouterApiKey {
+        function retrieve(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<OpenRouterApiKey>;
+        function create(openai: OpenAI, apiKey: string, options?: OpenAI.RequestOptions): Promise<OpenRouterApiKey>;
+        function remove(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<OpenRouterApiKey>;
+    }
+    interface Credits {
+        credits: number;
+        total_credits_purchased: number;
+        total_credits_used: number;
+    }
+    namespace Credits {
+        function retrieve(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<Credits>;
+    }
+}
+export interface Metadata {
+    query_requests: number;
+    query_completion_tokens: number;
+    query_prompt_tokens: number;
+    query_cost: number;
+    chat_requests: number;
+    chat_completion_tokens: number;
+    chat_prompt_tokens: number;
+    chat_cost: number;
+    embedding_completion_tokens: number;
+    embedding_prompt_tokens: number;
+    embedding_cost: number;
+}
+export declare namespace Metadata {
+    function get(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<Metadata>;
+}
+export interface QueryModelBase {
+    models: QueryModel.QueryLlmBase[];
+    weight: QueryModel.Weight;
+}
+export interface QueryModel {
+    name: string;
+    training_table_name?: string;
+    models: QueryModel.QueryLlm[];
+    weight: QueryModel.Weight;
+}
+export interface QueryModelWithMetadata extends QueryModel {
+    user_id: string;
+    created: string;
+    requests: number;
+    chat_completion_tokens: number;
+    chat_prompt_tokens: number;
+    chat_cost: number;
+    embedding_completion_tokens: number;
+    embedding_prompt_tokens: number;
+    embedding_cost: number;
+}
+export declare namespace QueryModel {
+    type Weight = Weight.Static | Weight.TrainingTable;
+    namespace Weight {
+        interface Static {
+            type: "static";
+        }
+        interface TrainingTable {
+            type: "training_table";
+            embeddings_model: string;
+            top: number;
+        }
+    }
+    interface QueryLlmBase {
+        id: string;
+        mode: QueryLlm.Mode;
+        select_top_logprobs?: number | null;
+        frequency_penalty?: number | null;
+        logit_bias?: Record<string, number> | null;
+        max_completion_tokens?: number | null;
+        presence_penalty?: number | null;
+        reasoning_effort?: Chat.Completions.Request.ReasoningEffort | null;
+        stop?: Chat.Completions.Request.Stop | null;
+        temperature?: number | null;
+        top_p?: number | null;
+        max_tokens?: number | null;
+        min_p?: number | null;
+        provider?: Chat.Completions.Request.ProviderPreferences | null;
+        reasoning?: Chat.Completions.Request.Reasoning | null;
+        repetition_penalty?: number | null;
+        top_a?: number | null;
+        top_k?: number | null;
+        verbosity?: Chat.Completions.Request.Verbosity | null;
+        models?: string[] | null;
+        weight: QueryLlm.Weight;
+    }
+    interface QueryLlmWithoutIndices extends QueryLlmBase {
+        name: string;
+        training_table_name?: string;
+    }
+    interface QueryLlm extends QueryLlmWithoutIndices {
+        index: number;
+        training_table_index?: number;
+    }
+    interface QueryLlmWithoutIndicesWithMetadata extends QueryLlmWithoutIndices {
+        user_id: string;
+        created: string;
+        requests: number;
+        chat_completion_tokens: number;
+        chat_prompt_tokens: number;
+        chat_cost: number;
+        embedding_completion_tokens: number;
+        embedding_prompt_tokens: number;
+        embedding_cost: number;
+    }
+    namespace QueryLlm {
+        type Mode = "generate" | "select_thinking" | "select_non_thinking" | "select_thinking_logprobs" | "select_non_thinking_logprobs";
+        type Weight = Weight.Static | Weight.TrainingTable;
+        namespace Weight {
+            interface Static {
+                type: "static";
+                weight: number;
+            }
+            interface TrainingTable {
+                type: "training_table";
+                base_weight: number;
+                min_weight: number;
+                max_weight: number;
+            }
+        }
+        function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndices>;
+        function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndicesWithMetadata>;
+        function retrieveValidate(openai: OpenAI, model: QueryLlmBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndices>;
+        function retrieveValidate(openai: OpenAI, model: QueryLlmBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryLlmWithoutIndicesWithMetadata>;
+    }
+    function list(openai: OpenAI, listOptions?: Models.ListOptions, options?: OpenAI.RequestOptions): Promise<{
+        data: string[];
+    }>;
+    function count(openai: OpenAI, options?: OpenAI.RequestOptions): Promise<{
+        count: number;
+    }>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryModel>;
+    function retrieve(openai: OpenAI, model: string, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryModelWithMetadata>;
+    function retrieveValidate(openai: OpenAI, model: QueryModelBase, retrieveOptions?: Models.RetrieveOptionsWithoutMetadata, options?: OpenAI.RequestOptions): Promise<QueryModel>;
+    function retrieveValidate(openai: OpenAI, model: QueryModelBase, retrieveOptions: Models.RetrieveOptionsWithMetadata, options?: OpenAI.RequestOptions): Promise<QueryModelWithMetadata>;
+}
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface ObjectiveAIError {
+    code: number;
+    message: JsonValue;
+}