import * as z from "zod/v3";
import { EventStream } from "../../lib/event-streams.js";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import * as components from "../components/index.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
/**
 * The effort level for reasoning
 */
export declare const Effort: {
    readonly None: "none";
    readonly Minimal: "minimal";
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
    readonly Xhigh: "xhigh";
};
/**
 * The effort level for reasoning
 */
export type Effort = ClosedEnum<typeof Effort>;
/**
 * The summary mode for reasoning output
 */
export declare const Summary: {
    readonly Auto: "auto";
    readonly Concise: "concise";
    readonly Detailed: "detailed";
};
/**
 * The summary mode for reasoning output
 */
export type Summary = ClosedEnum<typeof Summary>;
/**
 * Configuration for reasoning models
 */
export type Reasoning = {
    /**
     * The effort level for reasoning
     */
    effort?: Effort | undefined;
    /**
     * The summary mode for reasoning output
     */
    summary?: Summary | null | undefined;
};
/**
 * Configuration for thinking mode. Use `adaptive` for models that support it (e.g. Claude Opus 4.6, Sonnet 4.6), or `enabled` with `budget_tokens` for manual control.
 */
export type CreateResponseThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | components.ThinkingConfigAdaptiveSchema;
export type Format3 = {
    /**
     * Ensures the response matches a supplied JSON schema
     */
    type: "json_schema";
    /**
     * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
     */
    name: string;
    /**
     * A description of what the response format is for, used by the model to determine how to respond in the format.
     */
    description?: string | undefined;
    /**
     * The JSON schema to validate the response against
     */
    schema: {
        [k: string]: any;
    };
    /**
     * Whether to enable strict `schema` adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when `strict` is `true`
     */
    strict?: boolean | undefined;
};
export type Format2 = {
    /**
     * Ensures the response is a valid JSON object
     */
    type: "json_object";
};
export type Format1 = {
    /**
     * Plain text response format
     */
    type: "text";
};
export type CreateResponseFormat = Format1 | Format2 | Format3;
export type CreateResponseText = {
    format: Format1 | Format2 | Format3;
};
/**
 * The type of input item
 */
export declare const CreateResponse2RouterResponsesRequestRequestBodyInputType: {
    readonly FunctionCall: "function_call";
};
/**
 * The type of input item
 */
export type CreateResponse2RouterResponsesRequestRequestBodyInputType = ClosedEnum<typeof CreateResponse2RouterResponsesRequestRequestBodyInputType>;
/**
 * Represents a function tool call, provided as input to the model.
 */
export type CreateResponse23 = {
    /**
     * The type of input item
     */
    type: CreateResponse2RouterResponsesRequestRequestBodyInputType;
    /**
     * The ID of the function call
     */
    callId: string;
    /**
     * The unique identifier for this function call
     */
    id: string;
    /**
     * The name of the function being called
     */
    name: string;
    /**
     * The arguments to the function as a JSON string
     */
    arguments: string;
    /**
     * The status of the function call
     */
    status: string;
};
/**
 * The type of input item
 */
export declare const CreateResponse2RouterResponsesRequestRequestBodyType: {
    readonly FunctionCallOutput: "function_call_output";
};
/**
 * The type of input item
 */
export type CreateResponse2RouterResponsesRequestRequestBodyType = ClosedEnum<typeof CreateResponse2RouterResponsesRequestRequestBodyType>;
/**
 * Represents the output of a function tool call, provided as input to the model.
 */
export type CreateResponse2RouterResponses2 = {
    /**
     * The type of input item
     */
    type: CreateResponse2RouterResponsesRequestRequestBodyType;
    /**
     * The ID of the function call this output is for
     */
    callId: string;
    /**
     * The output from the function call
     */
    output: string;
};
/**
 * The role of the message author
 */
export declare const TwoRole: {
    readonly User: "user";
    readonly Assistant: "assistant";
    readonly System: "system";
    readonly Developer: "developer";
};
/**
 * The role of the message author
 */
export type TwoRole = ClosedEnum<typeof TwoRole>;
/**
 * A file input content part.
 */
export type Two3 = {
    /**
     * The type of input content part
     */
    type: "input_file";
    /**
     * Base64 encoded file data
     */
    fileData?: string | undefined;
    /**
     * File ID from the Files API
     */
    fileId?: string | undefined;
    /**
     * Name of the file
     */
    filename?: string | undefined;
    /**
     * URL of the file to fetch
     */
    fileUrl?: string | undefined;
};
/**
 * Level of detail for image analysis
 */
export declare const Detail: {
    readonly High: "high";
    readonly Low: "low";
    readonly Auto: "auto";
};
/**
 * Level of detail for image analysis
 */
export type Detail = ClosedEnum<typeof Detail>;
/**
 * An image input content part.
 */
export type CreateResponse22 = {
    /**
     * The type of input content part
     */
    type: "input_image";
    /**
     * Level of detail for image analysis
     */
    detail?: Detail | undefined;
    /**
     * File ID for the image
     */
    fileId?: string | null | undefined;
    /**
     * URL of the image (can be http URL or data URL)
     */
    imageUrl?: string | null | undefined;
};
/**
 * A text input content part
 */
export type CreateResponse21 = {
    /**
     * The type of input content
     */
    type: "input_text";
    /**
     * The text content
     */
    text: string;
};
export type CreateResponseContent2 = CreateResponse21 | CreateResponse22 | Two3;
/**
 * The content of the message, either a string or an array of content parts
 */
export type TwoContent = string | Array<CreateResponse21 | CreateResponse22 | Two3>;
/**
 * Represents a message in the conversation, with a role and content (string or rich content parts).
 */
export type Two1 = {
    /**
     * The role of the message author
     */
    role: TwoRole;
    /**
     * The content of the message, either a string or an array of content parts
     */
    content: string | Array<CreateResponse21 | CreateResponse22 | Two3>;
};
export type Input2 = CreateResponse23 | CreateResponse2RouterResponses2 | Two1;
/**
 * The actual user input(s) for the model. Can be a simple string, or an array of structured input items (messages, tool outputs) representing a conversation history or complex input.
 */
export type CreateResponseInput = string | Array<CreateResponse23 | CreateResponse2RouterResponses2 | Two1>;
export declare const Include: {
    readonly CodeInterpreterCallOutputs: "code_interpreter_call.outputs";
    readonly ComputerCallOutputOutputImageUrl: "computer_call_output.output.image_url";
    readonly FileSearchCallResults: "file_search_call.results";
    readonly MessageInputImageImageUrl: "message.input_image.image_url";
    readonly MessageOutputTextLogprobs: "message.output_text.logprobs";
    readonly ReasoningEncryptedContent: "reasoning.encrypted_content";
    readonly WebSearchCallResults: "web_search_call.results";
    readonly WebSearchCallActionSources: "web_search_call.action.sources";
};
export type Include = ClosedEnum<typeof Include>;
/**
 * Specifies the latency tier to use for processing the request. Defaults to "auto".
 */
export declare const ServiceTier: {
    readonly Auto: "auto";
    readonly Default: "default";
    readonly Flex: "flex";
    readonly Scale: "scale";
    readonly Priority: "priority";
};
/**
 * Specifies the latency tier to use for processing the request. Defaults to "auto".
 */
export type ServiceTier = ClosedEnum<typeof ServiceTier>;
/**
 * The ranking algorithm
 */
export declare const Ranker: {
    readonly Auto: "auto";
    readonly Default20240821: "default_2024_08_21";
};
/**
 * The ranking algorithm
 */
export type Ranker = ClosedEnum<typeof Ranker>;
/**
 * Options for ranking search results
 */
export type RankingOptions = {
    /**
     * The ranking algorithm
     */
    ranker?: Ranker | undefined;
    /**
     * Minimum relevance score
     */
    scoreThreshold?: number | undefined;
};
/**
 * Configuration for file search tool
 */
export type Tools4 = {
    /**
     * The type of tool
     */
    type: "file_search";
    /**
     * The vector stores to search
     */
    vectorStoreIds?: Array<string> | undefined;
    /**
     * Maximum number of results to return
     */
    maxNumResults?: number | undefined;
    /**
     * Filters to apply to the search
     */
    filters?: any | undefined;
    /**
     * Options for ranking search results
     */
    rankingOptions?: RankingOptions | undefined;
};
/**
 * Amount of context to retrieve for each search result
 */
export declare const ToolsSearchContextSize: {
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
};
/**
 * Amount of context to retrieve for each search result
 */
export type ToolsSearchContextSize = ClosedEnum<typeof ToolsSearchContextSize>;
/**
 * The type of location
 */
export declare const CreateResponseToolsRouterResponsesRequestRequestBodyType: {
    readonly Approximate: "approximate";
    readonly Exact: "exact";
};
/**
 * The type of location
 */
export type CreateResponseToolsRouterResponsesRequestRequestBodyType = ClosedEnum<typeof CreateResponseToolsRouterResponsesRequestRequestBodyType>;
/**
 * User location for search localization
 */
export type ToolsUserLocation = {
    /**
     * The type of location
     */
    type?: CreateResponseToolsRouterResponsesRequestRequestBodyType | undefined;
    /**
     * The city name
     */
    city?: string | null | undefined;
    /**
     * The country code
     */
    country?: string | undefined;
    /**
     * The region/state
     */
    region?: string | null | undefined;
    /**
     * The timezone
     */
    timezone?: string | null | undefined;
};
/**
 * Filters for the web search
 */
export type Filters = {
    /**
     * List of allowed domains for search
     */
    allowedDomains?: Array<string> | null | undefined;
};
/**
 * Configuration for web search tool
 */
export type Tools3 = {
    /**
     * The type of tool
     */
    type: "web_search";
    /**
     * Amount of context to retrieve for each search result
     */
    searchContextSize?: ToolsSearchContextSize | undefined;
    /**
     * User location for search localization
     */
    userLocation?: ToolsUserLocation | undefined;
    /**
     * Filters for the web search
     */
    filters?: Filters | null | undefined;
};
/**
 * Amount of context to retrieve for each search result
 */
export declare const SearchContextSize: {
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
};
/**
 * Amount of context to retrieve for each search result
 */
export type SearchContextSize = ClosedEnum<typeof SearchContextSize>;
/**
 * The type of location
 */
export declare const CreateResponseToolsRouterResponsesType: {
    readonly Approximate: "approximate";
    readonly Exact: "exact";
};
/**
 * The type of location
 */
export type CreateResponseToolsRouterResponsesType = ClosedEnum<typeof CreateResponseToolsRouterResponsesType>;
/**
 * User location for search localization
 */
export type UserLocation = {
    /**
     * The type of location
     */
    type?: CreateResponseToolsRouterResponsesType | undefined;
    /**
     * The city name
     */
    city?: string | null | undefined;
    /**
     * The country code
     */
    country?: string | undefined;
    /**
     * The region/state
     */
    region?: string | null | undefined;
    /**
     * The timezone
     */
    timezone?: string | null | undefined;
};
/**
 * Configuration for web search preview tool
 */
export type Tools2 = {
    /**
     * The type of tool
     */
    type: "web_search_preview";
    /**
     * List of domains to restrict search to
     */
    domains?: Array<string> | undefined;
    /**
     * Amount of context to retrieve for each search result
     */
    searchContextSize?: SearchContextSize | undefined;
    /**
     * User location for search localization
     */
    userLocation?: UserLocation | undefined;
};
/**
 * A function tool definition
 */
export type Tools1 = {
    /**
     * The type of tool
     */
    type: "function";
    /**
     * The name of the function to be called
     */
    name: string;
    /**
     * A description of what the function does
     */
    description?: string | null | undefined;
    /**
     * The parameters the function accepts as a JSON Schema object
     */
    parameters?: {
        [k: string]: any;
    } | null | undefined;
    /**
     * Whether to enable strict schema adherence when generating function calls
     */
    strict?: boolean | null | undefined;
};
export type CreateResponseTools = Tools1 | Tools2 | Tools3 | Tools4;
export declare const CreateResponseToolChoiceRouterResponsesRequestType: {
    readonly Mcp: "mcp";
};
export type CreateResponseToolChoiceRouterResponsesRequestType = ClosedEnum<typeof CreateResponseToolChoiceRouterResponsesRequestType>;
export type ToolChoice4 = {
    type: CreateResponseToolChoiceRouterResponsesRequestType;
    serverLabel: string;
    name?: string | null | undefined;
};
export declare const CreateResponseToolChoiceRouterResponsesType: {
    readonly Function: "function";
};
export type CreateResponseToolChoiceRouterResponsesType = ClosedEnum<typeof CreateResponseToolChoiceRouterResponsesType>;
export type ToolChoice3 = {
    type: CreateResponseToolChoiceRouterResponsesType;
    name: string;
};
export declare const CreateResponseToolChoiceType: {
    readonly FileSearch: "file_search";
    readonly WebSearchPreview: "web_search_preview";
    readonly WebSearchPreview20250311: "web_search_preview_2025_03_11";
    readonly WebSearch: "web_search";
    readonly ComputerUsePreview: "computer_use_preview";
    readonly ComputerUse: "computer_use";
    readonly Computer: "computer";
    readonly CodeInterpreter: "code_interpreter";
    readonly ImageGeneration: "image_generation";
};
export type CreateResponseToolChoiceType = ClosedEnum<typeof CreateResponseToolChoiceType>;
export type CreateResponseToolChoice2 = {
    type: CreateResponseToolChoiceType;
};
/**
 * Controls which (if any) tool is called by the model. `none` means the model will not call any tool. `auto` means the model can pick between generating a message or calling a tool. `required` means the model must call a tool.
 */
export declare const CreateResponseToolChoice1: {
    readonly None: "none";
    readonly Auto: "auto";
    readonly Required: "required";
};
/**
 * Controls which (if any) tool is called by the model. `none` means the model will not call any tool. `auto` means the model can pick between generating a message or calling a tool. `required` means the model must call a tool.
 */
export type CreateResponseToolChoice1 = ClosedEnum<typeof CreateResponseToolChoice1>;
/**
 * How the model should select which tool (or tools) to use when generating a response. Can be a string (`none`, `auto`, `required`) or an object to force a specific tool.
 */
export type CreateResponseToolChoice = ToolChoice3 | ToolChoice4 | CreateResponseToolChoice2 | CreateResponseToolChoice1;
export type CreateResponseRequestBody = {
    /**
     * ID of the model to use. You can use the List models API to see all of your available models.
     */
    model: string;
    /**
     * Developer-defined key-value pairs that will be included in response objects
     */
    metadata?: {
        [k: string]: string;
    } | undefined;
    /**
     * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
     */
    temperature?: number | null | undefined;
    /**
     * An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered.
     */
    topP?: number | null | undefined;
    /**
     * The ID of a previous response to continue the conversation from. The model will have access to the previous response context.
     */
    previousResponseId?: string | null | undefined;
    /**
     * Developer-provided instructions that the model should follow. Overwrites the default system message.
     */
    instructions?: string | null | undefined;
    /**
     * Configuration for reasoning models
     */
    reasoning?: Reasoning | null | undefined;
    /**
     * Configuration for thinking mode. Use `adaptive` for models that support it (e.g. Claude Opus 4.6, Sonnet 4.6), or `enabled` with `budget_tokens` for manual control.
     */
    thinking?: components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema | components.ThinkingConfigAdaptiveSchema | null | undefined;
    /**
     * The maximum number of tokens that can be generated in the response
     */
    maxOutputTokens?: number | null | undefined;
    text?: CreateResponseText | null | undefined;
    /**
     * The actual user input(s) for the model. Can be a simple string, or an array of structured input items (messages, tool outputs) representing a conversation history or complex input.
     */
    input: string | Array<CreateResponse23 | CreateResponse2RouterResponses2 | Two1>;
    /**
     * Specifies which (potentially large) fields to include in the response.
     */
    include?: Array<Include> | null | undefined;
    /**
     * Whether to enable parallel function calling during tool use.
     */
    parallelToolCalls?: boolean | null | undefined;
    /**
     * Whether to store this response for use in distillations or evals.
     */
    store?: boolean | null | undefined;
    /**
     * Specifies the latency tier to use for processing the request. Defaults to "auto".
     */
    serviceTier?: ServiceTier | null | undefined;
    /**
     * A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for.
     */
    tools?: Array<Tools1 | Tools2 | Tools3 | Tools4> | undefined;
    /**
     * How the model should select which tool (or tools) to use when generating a response. Can be a string (`none`, `auto`, `required`) or an object to force a specific tool.
     */
    toolChoice?: ToolChoice3 | ToolChoice4 | CreateResponseToolChoice2 | CreateResponseToolChoice1 | undefined;
    stream?: boolean | undefined;
};
/**
 * One server-sent event emitted while the response streams
 */
export type CreateResponseData = {
    /**
     * The type of streaming event
     */
    type: string;
    additionalProperties?: {
        [k: string]: any;
    } | undefined;
};
/**
 * One server-sent event emitted while the response streams
 */
export type CreateResponseRouterResponsesResponseBody = {
    /**
     * One server-sent event emitted while the response streams
     */
    data?: CreateResponseData | undefined;
};
/**
 * The object type, which is always "response"
 */
export declare const CreateResponseObject: {
    readonly Response: "response";
};
/**
 * The object type, which is always "response"
 */
export type CreateResponseObject = ClosedEnum<typeof CreateResponseObject>;
/**
 * The status of the response
 */
export declare const CreateResponseStatus: {
    readonly Completed: "completed";
    readonly Failed: "failed";
    readonly InProgress: "in_progress";
    readonly Cancelled: "cancelled";
    readonly Queued: "queued";
    readonly Incomplete: "incomplete";
};
/**
 * The status of the response
 */
export type CreateResponseStatus = ClosedEnum<typeof CreateResponseStatus>;
/**
 * The error that occurred, if any
 */
export type ErrorT = {
    /**
     * The error code
     */
    code: string;
    /**
     * The error message
     */
    message: string;
};
/**
 * The reason the response is incomplete
 */
export declare const Reason: {
    readonly MaxOutputTokens: "max_output_tokens";
    readonly ContentFilter: "content_filter";
};
/**
 * The reason the response is incomplete
 */
export type Reason = ClosedEnum<typeof Reason>;
/**
 * Details about why the response is incomplete
 */
export type IncompleteDetails = {
    /**
     * The reason the response is incomplete
     */
    reason: Reason;
};
/**
 * The type of summary part
 */
export declare const CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBody5Type: {
    readonly SummaryText: "summary_text";
};
/**
 * The type of summary part
 */
export type CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBody5Type = ClosedEnum<typeof CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBody5Type>;
/**
 * A text summary of the reasoning
 */
export type OutputSummary = {
    /**
     * The type of summary part
     */
    type: CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBody5Type;
    /**
     * The summary text
     */
    text: string;
};
/**
 * The status of the reasoning item
 */
export declare const CreateResponseOutputRouterResponsesResponse200Status: {
    readonly InProgress: "in_progress";
    readonly Completed: "completed";
    readonly Incomplete: "incomplete";
    readonly Failed: "failed";
};
/**
 * The status of the reasoning item
 */
export type CreateResponseOutputRouterResponsesResponse200Status = ClosedEnum<typeof CreateResponseOutputRouterResponsesResponse200Status>;
/**
 * A reasoning output item from the model
 */
export type Five = {
    /**
     * The unique identifier for this reasoning item
     */
    id: string;
    /**
     * The type of output item
     */
    type: "reasoning";
    /**
     * Summary of the reasoning
     */
    summary?: Array<OutputSummary> | undefined;
    /**
     * Encrypted reasoning content
     */
    encryptedContent?: string | null | undefined;
    /**
     * The status of the reasoning item
     */
    status?: CreateResponseOutputRouterResponsesResponse200Status | undefined;
};
/**
 * The status of the function call
 */
export declare const CreateResponseOutputRouterResponsesResponseStatus: {
    readonly InProgress: "in_progress";
    readonly Completed: "completed";
    readonly Incomplete: "incomplete";
    readonly Failed: "failed";
};
/**
 * The status of the function call
 */
export type CreateResponseOutputRouterResponsesResponseStatus = ClosedEnum<typeof CreateResponseOutputRouterResponsesResponseStatus>;
/**
 * A function tool call output
 */
export type Output4 = {
    /**
     * The unique identifier for this output item
     */
    id: string;
    /**
     * The type of output item
     */
    type: "function_call";
    /**
     * The ID of the function call
     */
    callId: string;
    /**
     * The name of the function being called
     */
    name: string;
    /**
     * The arguments to the function as a JSON string
     */
    arguments: string;
    /**
     * The status of the function call
     */
    status: CreateResponseOutputRouterResponsesResponseStatus;
};
/**
 * The status of the file search
 */
export declare const CreateResponseOutputRouterResponsesStatus: {
    readonly InProgress: "in_progress";
    readonly Completed: "completed";
    readonly Incomplete: "incomplete";
    readonly Failed: "failed";
};
/**
 * The status of the file search
 */
export type CreateResponseOutputRouterResponsesStatus = ClosedEnum<typeof CreateResponseOutputRouterResponsesStatus>;
/**
 * A file search tool call output
 */
export type Output3 = {
    /**
     * The unique identifier for this output item
     */
    id: string;
    /**
     * The type of output item
     */
    type: "file_search_call";
    /**
     * The status of the file search
     */
    status: CreateResponseOutputRouterResponsesStatus;
    /**
     * The search queries used
     */
    queries?: Array<string> | undefined;
    /**
     * The file search results
     */
    results?: any | undefined;
};
/**
 * The status of the web search
 */
export declare const CreateResponseOutputStatus: {
    readonly InProgress: "in_progress";
    readonly Completed: "completed";
    readonly Incomplete: "incomplete";
    readonly Failed: "failed";
};
/**
 * The status of the web search
 */
export type CreateResponseOutputStatus = ClosedEnum<typeof CreateResponseOutputStatus>;
/**
 * The type of web search action
 */
export declare const CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBodyType: {
    readonly Search: "search";
    readonly OpenPage: "open_page";
    readonly Find: "find";
};
/**
 * The type of web search action
 */
export type CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBodyType = ClosedEnum<typeof CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBodyType>;
export type Sources = {
    /**
     * The source URL
     */
    url: string;
    /**
     * The source title
     */
    title: string;
};
/**
 * The action performed by the web search
 */
export type Action = {
    /**
     * The type of web search action
     */
    type: CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBodyType;
    /**
     * The search query (for search action)
     */
    query?: string | undefined;
    /**
     * The URL opened (for open_page action)
     */
    url?: string | undefined;
    /**
     * The pattern to find (for find action)
     */
    pattern?: string | undefined;
    /**
     * Sources from the web search
     */
    sources?: Array<Sources> | undefined;
};
/**
 * A web search tool call output
 */
export type Output2 = {
    /**
     * The unique identifier for this output item
     */
    id: string;
    /**
     * The type of output item
     */
    type: "web_search_call";
    /**
     * The status of the web search
     */
    status: CreateResponseOutputStatus;
    /**
     * The action performed by the web search
     */
    action?: Action | undefined;
};
/**
 * The role of the message author
 */
export declare const OutputRole: {
    readonly Assistant: "assistant";
};
/**
 * The role of the message author
 */
export type OutputRole = ClosedEnum<typeof OutputRole>;
/**
 * The status of the message
 */
export declare const OutputStatus: {
    readonly InProgress: "in_progress";
    readonly Completed: "completed";
    readonly Incomplete: "incomplete";
    readonly Failed: "failed";
};
/**
 * The status of the message
 */
export type OutputStatus = ClosedEnum<typeof OutputStatus>;
/**
 * A refusal content part from the model
 */
export type CreateResponseContentRouterResponses2 = {
    /**
     * The type of content part
     */
    type: "refusal";
    /**
     * The refusal message
     */
    refusal: string;
};
/**
 * A citation to a file
 */
export type Annotations2 = {
    type: "file_citation";
    /**
     * The index in the text where the citation appears
     */
    index: number;
    /**
     * The ID of the file being cited
     */
    fileId: string;
    /**
     * The name of the file being cited
     */
    filename: string;
};
/**
 * A citation to a URL
 */
export type Annotations1 = {
    type: "url_citation";
    /**
     * The start index of the citation in the text
     */
    startIndex: number;
    /**
     * The end index of the citation in the text
     */
    endIndex: number;
    /**
     * The URL being cited
     */
    url: string;
    /**
     * The title of the cited resource
     */
    title: string;
    /**
     * The text of the citation
     */
    text?: string | undefined;
};
/**
 * An annotation in the output text
 */
export type ContentAnnotations = Annotations1 | Annotations2;
/**
 * Text output from the model
 */
export type Content1 = {
    /**
     * The type of content part
     */
    type: "output_text";
    /**
     * The text content
     */
    text: string;
    /**
     * Annotations in the text such as citations
     */
    annotations?: Array<Annotations1 | Annotations2> | undefined;
    /**
     * Log probabilities of the output tokens if requested
     */
    logprobs?: Array<any> | null | undefined;
};
export type OutputContent = Content1 | CreateResponseContentRouterResponses2;
/**
 * An assistant message output
 */
export type Output1 = {
    /**
     * The unique identifier for this message
     */
    id: string;
    /**
     * The type of output item
     */
    type: "message";
    /**
     * The role of the message author
     */
    role: OutputRole;
    /**
     * The status of the message
     */
    status: OutputStatus;
    /**
     * The content parts of the message
     */
    content?: Array<Content1 | CreateResponseContentRouterResponses2> | undefined;
};
export type Output = Output1 | Output2 | Output3 | Output4 | Five;
/**
 * Breakdown of input token usage
 */
export type CreateResponseInputTokensDetails = {
    /**
     * Number of tokens from cache
     */
    cachedTokens?: number | undefined;
};
/**
 * Breakdown of output token usage
 */
export type OutputTokensDetails = {
    /**
     * Number of tokens used for reasoning (o3 models)
     */
    reasoningTokens?: number | undefined;
    /**
     * Number of tokens generated by automatic prediction that were accepted
     */
    acceptedPredictionTokens?: number | undefined;
    /**
     * Number of tokens generated by automatic prediction that were rejected
     */
    rejectedPredictionTokens?: number | undefined;
};
/**
 * Usage statistics for the response
 */
export type CreateResponseUsage = {
    /**
     * Number of tokens in the input
     */
    inputTokens?: number | undefined;
    /**
     * Number of tokens in the generated output
     */
    outputTokens?: number | undefined;
    /**
     * Total number of tokens used in the request (input + output)
     */
    totalTokens?: number | undefined;
    /**
     * Breakdown of input token usage
     */
    inputTokensDetails?: CreateResponseInputTokensDetails | undefined;
    /**
     * Breakdown of output token usage
     */
    outputTokensDetails?: OutputTokensDetails | undefined;
};
export declare const CreateResponseToolChoiceRouterResponsesResponseType: {
    readonly Function: "function";
};
export type CreateResponseToolChoiceRouterResponsesResponseType = ClosedEnum<typeof CreateResponseToolChoiceRouterResponsesResponseType>;
export type CreateResponseToolChoiceFunction = {
    name: string;
};
export type CreateResponseToolChoiceRouterResponses2 = {
    type: CreateResponseToolChoiceRouterResponsesResponseType;
    function: CreateResponseToolChoiceFunction;
};
export declare const CreateResponseToolChoiceRouterResponses1: {
    readonly None: "none";
    readonly Auto: "auto";
    readonly Required: "required";
};
export type CreateResponseToolChoiceRouterResponses1 = ClosedEnum<typeof CreateResponseToolChoiceRouterResponses1>;
/**
 * Controls which (if any) tool is called by the model
 */
export type CreateResponseRouterResponsesToolChoice = CreateResponseToolChoiceRouterResponses2 | CreateResponseToolChoiceRouterResponses1;
/**
 * The ranking algorithm
 */
export declare const ToolsRanker: {
    readonly Auto: "auto";
    readonly Default20240821: "default_2024_08_21";
};
/**
 * The ranking algorithm
 */
export type ToolsRanker = ClosedEnum<typeof ToolsRanker>;
/**
 * Options for ranking search results
 */
export type ToolsRankingOptions = {
    /**
     * The ranking algorithm
     */
    ranker?: ToolsRanker | undefined;
    /**
     * Minimum relevance score
     */
    scoreThreshold?: number | undefined;
};
/**
 * Configuration for file search tool
 */
export type CreateResponseTools4 = {
    /**
     * The type of tool
     */
    type: "file_search";
    /**
     * The vector stores to search
     */
    vectorStoreIds?: Array<string> | undefined;
    /**
     * Maximum number of results to return
     */
    maxNumResults?: number | undefined;
    /**
     * Filters to apply to the search
     */
    filters?: any | undefined;
    /**
     * Options for ranking search results
     */
    rankingOptions?: ToolsRankingOptions | undefined;
};
/**
 * Amount of context to retrieve for each search result
 */
export declare const CreateResponseToolsRouterResponsesSearchContextSize: {
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
};
/**
 * Amount of context to retrieve for each search result
 */
export type CreateResponseToolsRouterResponsesSearchContextSize = ClosedEnum<typeof CreateResponseToolsRouterResponsesSearchContextSize>;
/**
 * The type of location
 */
export declare const CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody3Type: {
    readonly Approximate: "approximate";
    readonly Exact: "exact";
};
/**
 * The type of location
 */
export type CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody3Type = ClosedEnum<typeof CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody3Type>;
/**
 * User location for search localization
 */
export type CreateResponseToolsRouterResponsesUserLocation = {
    /**
     * The type of location
     */
    type?: CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody3Type | undefined;
    /**
     * The city name
     */
    city?: string | null | undefined;
    /**
     * The country code
     */
    country?: string | undefined;
    /**
     * The region/state
     */
    region?: string | null | undefined;
    /**
     * The timezone
     */
    timezone?: string | null | undefined;
};
/**
 * Filters for the web search
 */
export type ToolsFilters = {
    /**
     * List of allowed domains for search
     */
    allowedDomains?: Array<string> | null | undefined;
};
/**
 * Configuration for web search tool
 */
export type CreateResponseTools3 = {
    /**
     * The type of tool
     */
    type: "web_search";
    /**
     * Amount of context to retrieve for each search result
     */
    searchContextSize?: CreateResponseToolsRouterResponsesSearchContextSize | undefined;
    /**
     * User location for search localization
     */
    userLocation?: CreateResponseToolsRouterResponsesUserLocation | undefined;
    /**
     * Filters for the web search
     */
    filters?: ToolsFilters | null | undefined;
};
/**
 * Amount of context to retrieve for each search result
 */
export declare const CreateResponseToolsSearchContextSize: {
    readonly Low: "low";
    readonly Medium: "medium";
    readonly High: "high";
};
/**
 * Amount of context to retrieve for each search result
 */
export type CreateResponseToolsSearchContextSize = ClosedEnum<typeof CreateResponseToolsSearchContextSize>;
/**
 * The type of location
 */
export declare const CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody2Type: {
    readonly Approximate: "approximate";
    readonly Exact: "exact";
};
/**
 * The type of location
 */
export type CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody2Type = ClosedEnum<typeof CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody2Type>;
/**
 * User location for search localization
 */
export type CreateResponseToolsUserLocation = {
    /**
     * The type of location
     */
    type?: CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody2Type | undefined;
    /**
     * The city name
     */
    city?: string | null | undefined;
    /**
     * The country code
     */
    country?: string | undefined;
    /**
     * The region/state
     */
    region?: string | null | undefined;
    /**
     * The timezone
     */
    timezone?: string | null | undefined;
};
/**
 * Configuration for web search preview tool
 */
export type CreateResponseTools2 = {
    /**
     * The type of tool
     */
    type: "web_search_preview";
    /**
     * List of domains to restrict search to
     */
    domains?: Array<string> | undefined;
    /**
     * Amount of context to retrieve for each search result
     */
    searchContextSize?: CreateResponseToolsSearchContextSize | undefined;
    /**
     * User location for search localization
     */
    userLocation?: CreateResponseToolsUserLocation | undefined;
};
/**
 * A function tool definition
 */
export type CreateResponseTools1 = {
    /**
     * The type of tool
     */
    type: "function";
    /**
     * The name of the function to be called
     */
    name: string;
    /**
     * A description of what the function does
     */
    description?: string | null | undefined;
    /**
     * The parameters the function accepts as a JSON Schema object
     */
    parameters?: {
        [k: string]: any;
    } | null | undefined;
    /**
     * Whether to enable strict schema adherence when generating function calls
     */
    strict: boolean | null;
};
export type CreateResponseRouterResponsesTools = CreateResponseTools1 | CreateResponseTools2 | CreateResponseTools3 | CreateResponseTools4;
export type CreateResponseReasoning = {
    effort?: string | null | undefined;
    summary?: string | null | undefined;
};
export type CreateResponseFormat3 = {
    /**
     * Ensures the response matches a supplied JSON schema
     */
    type: "json_schema";
    /**
     * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
     */
    name: string;
    /**
     * A description of what the response format is for, used by the model to determine how to respond in the format.
     */
    description?: string | undefined;
    /**
     * The JSON schema to validate the response against
     */
    schema: {
        [k: string]: any;
    };
    /**
     * Whether to enable strict `schema` adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when `strict` is `true`
     */
    strict: boolean;
};
export type CreateResponseFormat2 = {
    /**
     * Ensures the response is a valid JSON object
     */
    type: "json_object";
};
export type CreateResponseFormat1 = {
    /**
     * Plain text response format
     */
    type: "text";
};
export type CreateResponseRouterResponsesFormat = CreateResponseFormat1 | CreateResponseFormat2 | CreateResponseFormat3;
export type CreateResponseRouterResponsesText = {
    format: CreateResponseFormat1 | CreateResponseFormat2 | CreateResponseFormat3;
};
/**
 * Controls how the model handles inputs longer than the maximum token length
 */
export declare const Truncation: {
    readonly Auto: "auto";
    readonly Disabled: "disabled";
};
/**
 * Controls how the model handles inputs longer than the maximum token length
 */
export type Truncation = ClosedEnum<typeof Truncation>;
/**
 * The service tier used for processing the request
 */
export declare const CreateResponseServiceTier: {
    readonly Auto: "auto";
    readonly Default: "default";
    readonly Flex: "flex";
    readonly Scale: "scale";
    readonly Priority: "priority";
};
/**
 * The service tier used for processing the request
 */
export type CreateResponseServiceTier = ClosedEnum<typeof CreateResponseServiceTier>;
/**
 * Represents the completed model response returned when `stream` is false
 */
export type CreateResponseResponseBody = {
    /**
     * The unique identifier for the response
     */
    id: string;
    /**
     * The object type, which is always "response"
     */
    object: CreateResponseObject;
    /**
     * The Unix timestamp (in seconds) of when the response was created
     */
    createdAt: number;
    /**
     * The status of the response
     */
    status: CreateResponseStatus;
    /**
     * The error that occurred, if any
     */
    error?: ErrorT | null | undefined;
    /**
     * Details about why the response is incomplete
     */
    incompleteDetails: IncompleteDetails | null;
    /**
     * The model used to generate the response
     */
    model: string;
    /**
     * The instructions provided for the response
     */
    instructions?: string | null | undefined;
    /**
     * The list of output items generated by the model
     */
    output: Array<Output1 | Output2 | Output3 | Output4 | Five>;
    /**
     * A convenience field with the concatenated text from all text content parts
     */
    outputText?: string | null | undefined;
    /**
     * Usage statistics for the response
     */
    usage?: CreateResponseUsage | undefined;
    temperature?: number | null | undefined;
    topP?: number | null | undefined;
    maxOutputTokens?: number | null | undefined;
    parallelToolCalls: boolean;
    previousResponseId?: string | null | undefined;
    metadata?: {
        [k: string]: string;
    } | undefined;
    /**
     * Controls which (if any) tool is called by the model
     */
    toolChoice?: CreateResponseToolChoiceRouterResponses2 | CreateResponseToolChoiceRouterResponses1 | undefined;
    tools?: Array<CreateResponseTools1 | CreateResponseTools2 | CreateResponseTools3 | CreateResponseTools4> | undefined;
    reasoning?: CreateResponseReasoning | null | undefined;
    store?: boolean | undefined;
    text?: CreateResponseRouterResponsesText | undefined;
    /**
     * Controls how the model handles inputs longer than the maximum token length
     */
    truncation?: Truncation | null | undefined;
    /**
     * A unique identifier representing your end-user
     */
    user?: string | null | undefined;
    /**
     * The service tier used for processing the request
     */
    serviceTier?: CreateResponseServiceTier | null | undefined;
    /**
     * Whether the response was processed in the background
     */
    background?: boolean | null | undefined;
    /**
     * The number of top log probabilities to return for each output token
     */
    topLogprobs?: number | null | undefined;
    /**
     * Whether to return log probabilities of the output tokens
     */
    logprobs?: boolean | null | undefined;
};
export type CreateResponseResponse = CreateResponseResponseBody | EventStream<CreateResponseRouterResponsesResponseBody>;
/** @internal */
export declare const Effort$outboundSchema: z.ZodNativeEnum<typeof Effort>;
/** @internal */
export declare const Summary$outboundSchema: z.ZodNativeEnum<typeof Summary>;
/** @internal */
export type Reasoning$Outbound = {
    effort?: string | undefined;
    summary?: string | null | undefined;
};
/** @internal */
export declare const Reasoning$outboundSchema: z.ZodType<Reasoning$Outbound, z.ZodTypeDef, Reasoning>;
export declare function reasoningToJSON(reasoning: Reasoning): string;
/** @internal */
export type CreateResponseThinking$Outbound = components.ThinkingConfigDisabledSchema$Outbound | components.ThinkingConfigEnabledSchema$Outbound | components.ThinkingConfigAdaptiveSchema$Outbound;
/** @internal */
export declare const CreateResponseThinking$outboundSchema: z.ZodType<CreateResponseThinking$Outbound, z.ZodTypeDef, CreateResponseThinking>;
export declare function createResponseThinkingToJSON(createResponseThinking: CreateResponseThinking): string;
/** @internal */
export type Format3$Outbound = {
    type: "json_schema";
    name: string;
    description?: string | undefined;
    schema: {
        [k: string]: any;
    };
    strict: boolean;
};
/** @internal */
export declare const Format3$outboundSchema: z.ZodType<Format3$Outbound, z.ZodTypeDef, Format3>;
export declare function format3ToJSON(format3: Format3): string;
/** @internal */
export type Format2$Outbound = {
    type: "json_object";
};
/** @internal */
export declare const Format2$outboundSchema: z.ZodType<Format2$Outbound, z.ZodTypeDef, Format2>;
export declare function format2ToJSON(format2: Format2): string;
/** @internal */
export type Format1$Outbound = {
    type: "text";
};
/** @internal */
export declare const Format1$outboundSchema: z.ZodType<Format1$Outbound, z.ZodTypeDef, Format1>;
export declare function format1ToJSON(format1: Format1): string;
/** @internal */
export type CreateResponseFormat$Outbound = Format1$Outbound | Format2$Outbound | Format3$Outbound;
/** @internal */
export declare const CreateResponseFormat$outboundSchema: z.ZodType<CreateResponseFormat$Outbound, z.ZodTypeDef, CreateResponseFormat>;
export declare function createResponseFormatToJSON(createResponseFormat: CreateResponseFormat): string;
/** @internal */
export type CreateResponseText$Outbound = {
    format: Format1$Outbound | Format2$Outbound | Format3$Outbound;
};
/** @internal */
export declare const CreateResponseText$outboundSchema: z.ZodType<CreateResponseText$Outbound, z.ZodTypeDef, CreateResponseText>;
export declare function createResponseTextToJSON(createResponseText: CreateResponseText): string;
/** @internal */
export declare const CreateResponse2RouterResponsesRequestRequestBodyInputType$outboundSchema: z.ZodNativeEnum<typeof CreateResponse2RouterResponsesRequestRequestBodyInputType>;
/** @internal */
export type CreateResponse23$Outbound = {
    type: string;
    call_id: string;
    id: string;
    name: string;
    arguments: string;
    status: string;
};
/** @internal */
export declare const CreateResponse23$outboundSchema: z.ZodType<CreateResponse23$Outbound, z.ZodTypeDef, CreateResponse23>;
export declare function createResponse23ToJSON(createResponse23: CreateResponse23): string;
/** @internal */
export declare const CreateResponse2RouterResponsesRequestRequestBodyType$outboundSchema: z.ZodNativeEnum<typeof CreateResponse2RouterResponsesRequestRequestBodyType>;
/** @internal */
export type CreateResponse2RouterResponses2$Outbound = {
    type: string;
    call_id: string;
    output: string;
};
/** @internal */
export declare const CreateResponse2RouterResponses2$outboundSchema: z.ZodType<CreateResponse2RouterResponses2$Outbound, z.ZodTypeDef, CreateResponse2RouterResponses2>;
export declare function createResponse2RouterResponses2ToJSON(createResponse2RouterResponses2: CreateResponse2RouterResponses2): string;
/** @internal */
export declare const TwoRole$outboundSchema: z.ZodNativeEnum<typeof TwoRole>;
/** @internal */
export type Two3$Outbound = {
    type: "input_file";
    file_data?: string | undefined;
    file_id?: string | undefined;
    filename?: string | undefined;
    file_url?: string | undefined;
};
/** @internal */
export declare const Two3$outboundSchema: z.ZodType<Two3$Outbound, z.ZodTypeDef, Two3>;
export declare function two3ToJSON(two3: Two3): string;
/** @internal */
export declare const Detail$outboundSchema: z.ZodNativeEnum<typeof Detail>;
/** @internal */
export type CreateResponse22$Outbound = {
    type: "input_image";
    detail: string;
    file_id?: string | null | undefined;
    image_url?: string | null | undefined;
};
/** @internal */
export declare const CreateResponse22$outboundSchema: z.ZodType<CreateResponse22$Outbound, z.ZodTypeDef, CreateResponse22>;
export declare function createResponse22ToJSON(createResponse22: CreateResponse22): string;
/** @internal */
export type CreateResponse21$Outbound = {
    type: "input_text";
    text: string;
};
/** @internal */
export declare const CreateResponse21$outboundSchema: z.ZodType<CreateResponse21$Outbound, z.ZodTypeDef, CreateResponse21>;
export declare function createResponse21ToJSON(createResponse21: CreateResponse21): string;
/** @internal */
export type CreateResponseContent2$Outbound = CreateResponse21$Outbound | CreateResponse22$Outbound | Two3$Outbound;
/** @internal */
export declare const CreateResponseContent2$outboundSchema: z.ZodType<CreateResponseContent2$Outbound, z.ZodTypeDef, CreateResponseContent2>;
export declare function createResponseContent2ToJSON(createResponseContent2: CreateResponseContent2): string;
/** @internal */
export type TwoContent$Outbound = string | Array<CreateResponse21$Outbound | CreateResponse22$Outbound | Two3$Outbound>;
/** @internal */
export declare const TwoContent$outboundSchema: z.ZodType<TwoContent$Outbound, z.ZodTypeDef, TwoContent>;
export declare function twoContentToJSON(twoContent: TwoContent): string;
/** @internal */
export type Two1$Outbound = {
    role: string;
    content: string | Array<CreateResponse21$Outbound | CreateResponse22$Outbound | Two3$Outbound>;
};
/** @internal */
export declare const Two1$outboundSchema: z.ZodType<Two1$Outbound, z.ZodTypeDef, Two1>;
export declare function two1ToJSON(two1: Two1): string;
/** @internal */
export type Input2$Outbound = CreateResponse23$Outbound | CreateResponse2RouterResponses2$Outbound | Two1$Outbound;
/** @internal */
export declare const Input2$outboundSchema: z.ZodType<Input2$Outbound, z.ZodTypeDef, Input2>;
export declare function input2ToJSON(input2: Input2): string;
/** @internal */
export type CreateResponseInput$Outbound = string | Array<CreateResponse23$Outbound | CreateResponse2RouterResponses2$Outbound | Two1$Outbound>;
/** @internal */
export declare const CreateResponseInput$outboundSchema: z.ZodType<CreateResponseInput$Outbound, z.ZodTypeDef, CreateResponseInput>;
export declare function createResponseInputToJSON(createResponseInput: CreateResponseInput): string;
/** @internal */
export declare const Include$outboundSchema: z.ZodNativeEnum<typeof Include>;
/** @internal */
export declare const ServiceTier$outboundSchema: z.ZodNativeEnum<typeof ServiceTier>;
/** @internal */
export declare const Ranker$outboundSchema: z.ZodNativeEnum<typeof Ranker>;
/** @internal */
export type RankingOptions$Outbound = {
    ranker?: string | undefined;
    score_threshold?: number | undefined;
};
/** @internal */
export declare const RankingOptions$outboundSchema: z.ZodType<RankingOptions$Outbound, z.ZodTypeDef, RankingOptions>;
export declare function rankingOptionsToJSON(rankingOptions: RankingOptions): string;
/** @internal */
export type Tools4$Outbound = {
    type: "file_search";
    vector_store_ids?: Array<string> | undefined;
    max_num_results?: number | undefined;
    filters?: any | undefined;
    ranking_options?: RankingOptions$Outbound | undefined;
};
/** @internal */
export declare const Tools4$outboundSchema: z.ZodType<Tools4$Outbound, z.ZodTypeDef, Tools4>;
export declare function tools4ToJSON(tools4: Tools4): string;
/** @internal */
export declare const ToolsSearchContextSize$outboundSchema: z.ZodNativeEnum<typeof ToolsSearchContextSize>;
/** @internal */
export declare const CreateResponseToolsRouterResponsesRequestRequestBodyType$outboundSchema: z.ZodNativeEnum<typeof CreateResponseToolsRouterResponsesRequestRequestBodyType>;
/** @internal */
export type ToolsUserLocation$Outbound = {
    type?: string | undefined;
    city?: string | null | undefined;
    country?: string | undefined;
    region?: string | null | undefined;
    timezone?: string | null | undefined;
};
/** @internal */
export declare const ToolsUserLocation$outboundSchema: z.ZodType<ToolsUserLocation$Outbound, z.ZodTypeDef, ToolsUserLocation>;
export declare function toolsUserLocationToJSON(toolsUserLocation: ToolsUserLocation): string;
/** @internal */
export type Filters$Outbound = {
    allowed_domains?: Array<string> | null | undefined;
};
/** @internal */
export declare const Filters$outboundSchema: z.ZodType<Filters$Outbound, z.ZodTypeDef, Filters>;
export declare function filtersToJSON(filters: Filters): string;
/** @internal */
export type Tools3$Outbound = {
    type: "web_search";
    search_context_size?: string | undefined;
    user_location?: ToolsUserLocation$Outbound | undefined;
    filters?: Filters$Outbound | null | undefined;
};
/** @internal */
export declare const Tools3$outboundSchema: z.ZodType<Tools3$Outbound, z.ZodTypeDef, Tools3>;
export declare function tools3ToJSON(tools3: Tools3): string;
/** @internal */
export declare const SearchContextSize$outboundSchema: z.ZodNativeEnum<typeof SearchContextSize>;
/** @internal */
export declare const CreateResponseToolsRouterResponsesType$outboundSchema: z.ZodNativeEnum<typeof CreateResponseToolsRouterResponsesType>;
/** @internal */
export type UserLocation$Outbound = {
    type?: string | undefined;
    city?: string | null | undefined;
    country?: string | undefined;
    region?: string | null | undefined;
    timezone?: string | null | undefined;
};
/** @internal */
export declare const UserLocation$outboundSchema: z.ZodType<UserLocation$Outbound, z.ZodTypeDef, UserLocation>;
export declare function userLocationToJSON(userLocation: UserLocation): string;
/** @internal */
export type Tools2$Outbound = {
    type: "web_search_preview";
    domains?: Array<string> | undefined;
    search_context_size?: string | undefined;
    user_location?: UserLocation$Outbound | undefined;
};
/** @internal */
export declare const Tools2$outboundSchema: z.ZodType<Tools2$Outbound, z.ZodTypeDef, Tools2>;
export declare function tools2ToJSON(tools2: Tools2): string;
/** @internal */
export type Tools1$Outbound = {
    type: "function";
    name: string;
    description?: string | null | undefined;
    parameters?: {
        [k: string]: any;
    } | null | undefined;
    strict: boolean | null;
};
/** @internal */
export declare const Tools1$outboundSchema: z.ZodType<Tools1$Outbound, z.ZodTypeDef, Tools1>;
export declare function tools1ToJSON(tools1: Tools1): string;
/** @internal */
export type CreateResponseTools$Outbound = Tools1$Outbound | Tools2$Outbound | Tools3$Outbound | Tools4$Outbound;
/** @internal */
export declare const CreateResponseTools$outboundSchema: z.ZodType<CreateResponseTools$Outbound, z.ZodTypeDef, CreateResponseTools>;
export declare function createResponseToolsToJSON(createResponseTools: CreateResponseTools): string;
/** @internal */
export declare const CreateResponseToolChoiceRouterResponsesRequestType$outboundSchema: z.ZodNativeEnum<typeof CreateResponseToolChoiceRouterResponsesRequestType>;
/** @internal */
export type ToolChoice4$Outbound = {
    type: string;
    server_label: string;
    name?: string | null | undefined;
};
/** @internal */
export declare const ToolChoice4$outboundSchema: z.ZodType<ToolChoice4$Outbound, z.ZodTypeDef, ToolChoice4>;
export declare function toolChoice4ToJSON(toolChoice4: ToolChoice4): string;
/** @internal */
export declare const CreateResponseToolChoiceRouterResponsesType$outboundSchema: z.ZodNativeEnum<typeof CreateResponseToolChoiceRouterResponsesType>;
/** @internal */
export type ToolChoice3$Outbound = {
    type: string;
    name: string;
};
/** @internal */
export declare const ToolChoice3$outboundSchema: z.ZodType<ToolChoice3$Outbound, z.ZodTypeDef, ToolChoice3>;
export declare function toolChoice3ToJSON(toolChoice3: ToolChoice3): string;
/** @internal */
export declare const CreateResponseToolChoiceType$outboundSchema: z.ZodNativeEnum<typeof CreateResponseToolChoiceType>;
/** @internal */
export type CreateResponseToolChoice2$Outbound = {
    type: string;
};
/** @internal */
export declare const CreateResponseToolChoice2$outboundSchema: z.ZodType<CreateResponseToolChoice2$Outbound, z.ZodTypeDef, CreateResponseToolChoice2>;
export declare function createResponseToolChoice2ToJSON(createResponseToolChoice2: CreateResponseToolChoice2): string;
/** @internal */
export declare const CreateResponseToolChoice1$outboundSchema: z.ZodNativeEnum<typeof CreateResponseToolChoice1>;
/** @internal */
export type CreateResponseToolChoice$Outbound = ToolChoice3$Outbound | ToolChoice4$Outbound | CreateResponseToolChoice2$Outbound | string;
/** @internal */
export declare const CreateResponseToolChoice$outboundSchema: z.ZodType<CreateResponseToolChoice$Outbound, z.ZodTypeDef, CreateResponseToolChoice>;
export declare function createResponseToolChoiceToJSON(createResponseToolChoice: CreateResponseToolChoice): string;
/** @internal */
export type CreateResponseRequestBody$Outbound = {
    model: string;
    metadata?: {
        [k: string]: string;
    } | undefined;
    temperature?: number | null | undefined;
    top_p?: number | null | undefined;
    previous_response_id?: string | null | undefined;
    instructions?: string | null | undefined;
    reasoning?: Reasoning$Outbound | null | undefined;
    thinking?: components.ThinkingConfigDisabledSchema$Outbound | components.ThinkingConfigEnabledSchema$Outbound | components.ThinkingConfigAdaptiveSchema$Outbound | null | undefined;
    max_output_tokens?: number | null | undefined;
    text?: CreateResponseText$Outbound | null | undefined;
    input: string | Array<CreateResponse23$Outbound | CreateResponse2RouterResponses2$Outbound | Two1$Outbound>;
    include?: Array<string> | null | undefined;
    parallel_tool_calls?: boolean | null | undefined;
    store?: boolean | null | undefined;
    service_tier?: string | null | undefined;
    tools?: Array<Tools1$Outbound | Tools2$Outbound | Tools3$Outbound | Tools4$Outbound> | undefined;
    tool_choice?: ToolChoice3$Outbound | ToolChoice4$Outbound | CreateResponseToolChoice2$Outbound | string | undefined;
    stream: boolean;
};
/** @internal */
export declare const CreateResponseRequestBody$outboundSchema: z.ZodType<CreateResponseRequestBody$Outbound, z.ZodTypeDef, CreateResponseRequestBody>;
export declare function createResponseRequestBodyToJSON(createResponseRequestBody: CreateResponseRequestBody): string;
/** @internal */
export declare const CreateResponseData$inboundSchema: z.ZodType<CreateResponseData, z.ZodTypeDef, unknown>;
export declare function createResponseDataFromJSON(jsonString: string): SafeParseResult<CreateResponseData, SDKValidationError>;
/** @internal */
export declare const CreateResponseRouterResponsesResponseBody$inboundSchema: z.ZodType<CreateResponseRouterResponsesResponseBody, z.ZodTypeDef, unknown>;
export declare function createResponseRouterResponsesResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateResponseRouterResponsesResponseBody, SDKValidationError>;
/** @internal */
export declare const CreateResponseObject$inboundSchema: z.ZodNativeEnum<typeof CreateResponseObject>;
/** @internal */
export declare const CreateResponseStatus$inboundSchema: z.ZodNativeEnum<typeof CreateResponseStatus>;
/** @internal */
export declare const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown>;
export declare function errorFromJSON(jsonString: string): SafeParseResult<ErrorT, SDKValidationError>;
/** @internal */
export declare const Reason$inboundSchema: z.ZodNativeEnum<typeof Reason>;
/** @internal */
export declare const IncompleteDetails$inboundSchema: z.ZodType<IncompleteDetails, z.ZodTypeDef, unknown>;
export declare function incompleteDetailsFromJSON(jsonString: string): SafeParseResult<IncompleteDetails, SDKValidationError>;
/** @internal */
export declare const CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBody5Type$inboundSchema: z.ZodNativeEnum<typeof CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBody5Type>;
/** @internal */
export declare const OutputSummary$inboundSchema: z.ZodType<OutputSummary, z.ZodTypeDef, unknown>;
export declare function outputSummaryFromJSON(jsonString: string): SafeParseResult<OutputSummary, SDKValidationError>;
/** @internal */
export declare const CreateResponseOutputRouterResponsesResponse200Status$inboundSchema: z.ZodNativeEnum<typeof CreateResponseOutputRouterResponsesResponse200Status>;
/** @internal */
export declare const Five$inboundSchema: z.ZodType<Five, z.ZodTypeDef, unknown>;
export declare function fiveFromJSON(jsonString: string): SafeParseResult<Five, SDKValidationError>;
/** @internal */
export declare const CreateResponseOutputRouterResponsesResponseStatus$inboundSchema: z.ZodNativeEnum<typeof CreateResponseOutputRouterResponsesResponseStatus>;
/** @internal */
export declare const Output4$inboundSchema: z.ZodType<Output4, z.ZodTypeDef, unknown>;
export declare function output4FromJSON(jsonString: string): SafeParseResult<Output4, SDKValidationError>;
/** @internal */
export declare const CreateResponseOutputRouterResponsesStatus$inboundSchema: z.ZodNativeEnum<typeof CreateResponseOutputRouterResponsesStatus>;
/** @internal */
export declare const Output3$inboundSchema: z.ZodType<Output3, z.ZodTypeDef, unknown>;
export declare function output3FromJSON(jsonString: string): SafeParseResult<Output3, SDKValidationError>;
/** @internal */
export declare const CreateResponseOutputStatus$inboundSchema: z.ZodNativeEnum<typeof CreateResponseOutputStatus>;
/** @internal */
export declare const CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBodyType$inboundSchema: z.ZodNativeEnum<typeof CreateResponseOutputRouterResponsesResponse200ApplicationJSONResponseBodyType>;
/** @internal */
export declare const Sources$inboundSchema: z.ZodType<Sources, z.ZodTypeDef, unknown>;
export declare function sourcesFromJSON(jsonString: string): SafeParseResult<Sources, SDKValidationError>;
/** @internal */
export declare const Action$inboundSchema: z.ZodType<Action, z.ZodTypeDef, unknown>;
export declare function actionFromJSON(jsonString: string): SafeParseResult<Action, SDKValidationError>;
/** @internal */
export declare const Output2$inboundSchema: z.ZodType<Output2, z.ZodTypeDef, unknown>;
export declare function output2FromJSON(jsonString: string): SafeParseResult<Output2, SDKValidationError>;
/** @internal */
export declare const OutputRole$inboundSchema: z.ZodNativeEnum<typeof OutputRole>;
/** @internal */
export declare const OutputStatus$inboundSchema: z.ZodNativeEnum<typeof OutputStatus>;
/** @internal */
export declare const CreateResponseContentRouterResponses2$inboundSchema: z.ZodType<CreateResponseContentRouterResponses2, z.ZodTypeDef, unknown>;
export declare function createResponseContentRouterResponses2FromJSON(jsonString: string): SafeParseResult<CreateResponseContentRouterResponses2, SDKValidationError>;
/** @internal */
export declare const Annotations2$inboundSchema: z.ZodType<Annotations2, z.ZodTypeDef, unknown>;
export declare function annotations2FromJSON(jsonString: string): SafeParseResult<Annotations2, SDKValidationError>;
/** @internal */
export declare const Annotations1$inboundSchema: z.ZodType<Annotations1, z.ZodTypeDef, unknown>;
export declare function annotations1FromJSON(jsonString: string): SafeParseResult<Annotations1, SDKValidationError>;
/** @internal */
export declare const ContentAnnotations$inboundSchema: z.ZodType<ContentAnnotations, z.ZodTypeDef, unknown>;
export declare function contentAnnotationsFromJSON(jsonString: string): SafeParseResult<ContentAnnotations, SDKValidationError>;
/** @internal */
export declare const Content1$inboundSchema: z.ZodType<Content1, z.ZodTypeDef, unknown>;
export declare function content1FromJSON(jsonString: string): SafeParseResult<Content1, SDKValidationError>;
/** @internal */
export declare const OutputContent$inboundSchema: z.ZodType<OutputContent, z.ZodTypeDef, unknown>;
export declare function outputContentFromJSON(jsonString: string): SafeParseResult<OutputContent, SDKValidationError>;
/** @internal */
export declare const Output1$inboundSchema: z.ZodType<Output1, z.ZodTypeDef, unknown>;
export declare function output1FromJSON(jsonString: string): SafeParseResult<Output1, SDKValidationError>;
/** @internal */
export declare const Output$inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown>;
export declare function outputFromJSON(jsonString: string): SafeParseResult<Output, SDKValidationError>;
/** @internal */
export declare const CreateResponseInputTokensDetails$inboundSchema: z.ZodType<CreateResponseInputTokensDetails, z.ZodTypeDef, unknown>;
export declare function createResponseInputTokensDetailsFromJSON(jsonString: string): SafeParseResult<CreateResponseInputTokensDetails, SDKValidationError>;
/** @internal */
export declare const OutputTokensDetails$inboundSchema: z.ZodType<OutputTokensDetails, z.ZodTypeDef, unknown>;
export declare function outputTokensDetailsFromJSON(jsonString: string): SafeParseResult<OutputTokensDetails, SDKValidationError>;
/** @internal */
export declare const CreateResponseUsage$inboundSchema: z.ZodType<CreateResponseUsage, z.ZodTypeDef, unknown>;
export declare function createResponseUsageFromJSON(jsonString: string): SafeParseResult<CreateResponseUsage, SDKValidationError>;
/** @internal */
export declare const CreateResponseToolChoiceRouterResponsesResponseType$inboundSchema: z.ZodNativeEnum<typeof CreateResponseToolChoiceRouterResponsesResponseType>;
/** @internal */
export declare const CreateResponseToolChoiceFunction$inboundSchema: z.ZodType<CreateResponseToolChoiceFunction, z.ZodTypeDef, unknown>;
export declare function createResponseToolChoiceFunctionFromJSON(jsonString: string): SafeParseResult<CreateResponseToolChoiceFunction, SDKValidationError>;
/** @internal */
export declare const CreateResponseToolChoiceRouterResponses2$inboundSchema: z.ZodType<CreateResponseToolChoiceRouterResponses2, z.ZodTypeDef, unknown>;
export declare function createResponseToolChoiceRouterResponses2FromJSON(jsonString: string): SafeParseResult<CreateResponseToolChoiceRouterResponses2, SDKValidationError>;
/** @internal */
export declare const CreateResponseToolChoiceRouterResponses1$inboundSchema: z.ZodNativeEnum<typeof CreateResponseToolChoiceRouterResponses1>;
/** @internal */
export declare const CreateResponseRouterResponsesToolChoice$inboundSchema: z.ZodType<CreateResponseRouterResponsesToolChoice, z.ZodTypeDef, unknown>;
export declare function createResponseRouterResponsesToolChoiceFromJSON(jsonString: string): SafeParseResult<CreateResponseRouterResponsesToolChoice, SDKValidationError>;
/** @internal */
export declare const ToolsRanker$inboundSchema: z.ZodNativeEnum<typeof ToolsRanker>;
/** @internal */
export declare const ToolsRankingOptions$inboundSchema: z.ZodType<ToolsRankingOptions, z.ZodTypeDef, unknown>;
export declare function toolsRankingOptionsFromJSON(jsonString: string): SafeParseResult<ToolsRankingOptions, SDKValidationError>;
/** @internal */
export declare const CreateResponseTools4$inboundSchema: z.ZodType<CreateResponseTools4, z.ZodTypeDef, unknown>;
export declare function createResponseTools4FromJSON(jsonString: string): SafeParseResult<CreateResponseTools4, SDKValidationError>;
/** @internal */
export declare const CreateResponseToolsRouterResponsesSearchContextSize$inboundSchema: z.ZodNativeEnum<typeof CreateResponseToolsRouterResponsesSearchContextSize>;
/** @internal */
export declare const CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody3Type$inboundSchema: z.ZodNativeEnum<typeof CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody3Type>;
/** @internal */
export declare const CreateResponseToolsRouterResponsesUserLocation$inboundSchema: z.ZodType<CreateResponseToolsRouterResponsesUserLocation, z.ZodTypeDef, unknown>;
export declare function createResponseToolsRouterResponsesUserLocationFromJSON(jsonString: string): SafeParseResult<CreateResponseToolsRouterResponsesUserLocation, SDKValidationError>;
/** @internal */
export declare const ToolsFilters$inboundSchema: z.ZodType<ToolsFilters, z.ZodTypeDef, unknown>;
export declare function toolsFiltersFromJSON(jsonString: string): SafeParseResult<ToolsFilters, SDKValidationError>;
/** @internal */
export declare const CreateResponseTools3$inboundSchema: z.ZodType<CreateResponseTools3, z.ZodTypeDef, unknown>;
export declare function createResponseTools3FromJSON(jsonString: string): SafeParseResult<CreateResponseTools3, SDKValidationError>;
/** @internal */
export declare const CreateResponseToolsSearchContextSize$inboundSchema: z.ZodNativeEnum<typeof CreateResponseToolsSearchContextSize>;
/** @internal */
export declare const CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody2Type$inboundSchema: z.ZodNativeEnum<typeof CreateResponseToolsRouterResponsesResponse200ApplicationJSONResponseBody2Type>;
/** @internal */
export declare const CreateResponseToolsUserLocation$inboundSchema: z.ZodType<CreateResponseToolsUserLocation, z.ZodTypeDef, unknown>;
export declare function createResponseToolsUserLocationFromJSON(jsonString: string): SafeParseResult<CreateResponseToolsUserLocation, SDKValidationError>;
/** @internal */
export declare const CreateResponseTools2$inboundSchema: z.ZodType<CreateResponseTools2, z.ZodTypeDef, unknown>;
export declare function createResponseTools2FromJSON(jsonString: string): SafeParseResult<CreateResponseTools2, SDKValidationError>;
/** @internal */
export declare const CreateResponseTools1$inboundSchema: z.ZodType<CreateResponseTools1, z.ZodTypeDef, unknown>;
export declare function createResponseTools1FromJSON(jsonString: string): SafeParseResult<CreateResponseTools1, SDKValidationError>;
/** @internal */
export declare const CreateResponseRouterResponsesTools$inboundSchema: z.ZodType<CreateResponseRouterResponsesTools, z.ZodTypeDef, unknown>;
export declare function createResponseRouterResponsesToolsFromJSON(jsonString: string): SafeParseResult<CreateResponseRouterResponsesTools, SDKValidationError>;
/** @internal */
export declare const CreateResponseReasoning$inboundSchema: z.ZodType<CreateResponseReasoning, z.ZodTypeDef, unknown>;
export declare function createResponseReasoningFromJSON(jsonString: string): SafeParseResult<CreateResponseReasoning, SDKValidationError>;
/** @internal */
export declare const CreateResponseFormat3$inboundSchema: z.ZodType<CreateResponseFormat3, z.ZodTypeDef, unknown>;
export declare function createResponseFormat3FromJSON(jsonString: string): SafeParseResult<CreateResponseFormat3, SDKValidationError>;
/** @internal */
export declare const CreateResponseFormat2$inboundSchema: z.ZodType<CreateResponseFormat2, z.ZodTypeDef, unknown>;
export declare function createResponseFormat2FromJSON(jsonString: string): SafeParseResult<CreateResponseFormat2, SDKValidationError>;
/** @internal */
export declare const CreateResponseFormat1$inboundSchema: z.ZodType<CreateResponseFormat1, z.ZodTypeDef, unknown>;
export declare function createResponseFormat1FromJSON(jsonString: string): SafeParseResult<CreateResponseFormat1, SDKValidationError>;
/** @internal */
export declare const CreateResponseRouterResponsesFormat$inboundSchema: z.ZodType<CreateResponseRouterResponsesFormat, z.ZodTypeDef, unknown>;
export declare function createResponseRouterResponsesFormatFromJSON(jsonString: string): SafeParseResult<CreateResponseRouterResponsesFormat, SDKValidationError>;
/** @internal */
export declare const CreateResponseRouterResponsesText$inboundSchema: z.ZodType<CreateResponseRouterResponsesText, z.ZodTypeDef, unknown>;
export declare function createResponseRouterResponsesTextFromJSON(jsonString: string): SafeParseResult<CreateResponseRouterResponsesText, SDKValidationError>;
/** @internal */
export declare const Truncation$inboundSchema: z.ZodNativeEnum<typeof Truncation>;
/** @internal */
export declare const CreateResponseServiceTier$inboundSchema: z.ZodNativeEnum<typeof CreateResponseServiceTier>;
/** @internal */
export declare const CreateResponseResponseBody$inboundSchema: z.ZodType<CreateResponseResponseBody, z.ZodTypeDef, unknown>;
export declare function createResponseResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateResponseResponseBody, SDKValidationError>;
/** @internal */
export declare const CreateResponseResponse$inboundSchema: z.ZodType<CreateResponseResponse, z.ZodTypeDef, unknown>;
export declare function createResponseResponseFromJSON(jsonString: string): SafeParseResult<CreateResponseResponse, SDKValidationError>;
//# sourceMappingURL=createresponse.d.ts.map