import { APIResource } from "../core/resource.js";
import * as ResponsesAPI from "./responses.js";
import { APIPromise } from "../core/api-promise.js";
import { RequestOptions } from "../internal/request-options.js";
export declare class Responses extends APIResource {
    /**
     * Runs inference using the OpenAI Responses API contract, taking an `input` rather
     * than a chat `messages` array.
     *
     * This endpoint is restricted to OpenAI-vendor models: requests whose `model`
     * (`vendor/name`) resolves to any other vendor are rejected with an
     * unsupported-vendor error, unlike /v5/chat/completions and /v5/inference which
     * support many vendors. Use it when you specifically need Responses API features
     * such as `previous_response_id` chaining, `instructions`, or `store`; use
     * /v5/chat/completions for the standard messages-based chat contract. When
     * `stream` is set the response streams as server-sent events; otherwise a single
     * `response` object is returned.
     */
    create(body: ResponseCreateParams, options?: RequestOptions): APIPromise<ResponseCreateResponse>;
}
/**
 * A tool call representing a request to create, delete, or update files using diff
 * patches.
 */
export interface ApplyPatchCall {
    call_id: string;
    /**
     * Instruction for creating a new file via the apply_patch tool.
     */
    operation: ApplyPatchCall.ApplyPatchCallOperationCreateFile | ApplyPatchCall.ApplyPatchCallOperationDeleteFile | ApplyPatchCall.ApplyPatchCallOperationUpdateFile;
    status: 'in_progress' | 'completed';
    type: 'apply_patch_call';
    id?: string;
    [k: string]: unknown;
}
export declare namespace ApplyPatchCall {
    /**
     * Instruction for creating a new file via the apply_patch tool.
     */
    interface ApplyPatchCallOperationCreateFile {
        diff: string;
        path: string;
        type: 'create_file';
        [k: string]: unknown;
    }
    /**
     * Instruction for deleting an existing file via the apply_patch tool.
     */
    interface ApplyPatchCallOperationDeleteFile {
        path: string;
        type: 'delete_file';
        [k: string]: unknown;
    }
    /**
     * Instruction for updating an existing file via the apply_patch tool.
     */
    interface ApplyPatchCallOperationUpdateFile {
        diff: string;
        path: string;
        type: 'update_file';
        [k: string]: unknown;
    }
}
/**
 * The streamed output emitted by an apply patch tool call.
 */
export interface ApplyPatchCallOutput {
    call_id: string;
    status: 'completed' | 'failed';
    type: 'apply_patch_call_output';
    id?: string;
    output?: string;
    [k: string]: unknown;
}
/**
 * Allows the assistant to create, delete, or update files using unified diffs.
 */
export interface ApplyPatchTool {
    type: 'apply_patch';
    [k: string]: unknown;
}
/**
 * A tool that controls a virtual computer.
 *
 * Learn more about the
 * [computer tool](https://platform.openai.com/docs/guides/tools-computer-use).
 */
export interface ComputerTool {
    display_height: number;
    display_width: number;
    environment: 'windows' | 'mac' | 'linux' | 'ubuntu' | 'browser';
    type: 'computer_use_preview';
    [k: string]: unknown;
}
export interface ContainerNetworkPolicyAllowlist {
    allowed_domains: Array<string>;
    type: 'allowlist';
    domain_secrets?: Array<ContainerNetworkPolicyAllowlist.DomainSecret>;
    [k: string]: unknown;
}
export declare namespace ContainerNetworkPolicyAllowlist {
    interface DomainSecret {
        domain: string;
        name: string;
        value: string;
        [k: string]: unknown;
    }
}
export interface ContainerNetworkPolicyDisabled {
    type: 'disabled';
    [k: string]: unknown;
}
export interface ContainerReference {
    container_id: string;
    type: 'container_reference';
    [k: string]: unknown;
}
export interface ContainerReferenceParam {
    container_id: string;
    type: 'container_reference';
    [k: string]: unknown;
}
/**
 * The conversation that this response belonged to.
 *
 * Input items and output items from this response were automatically added to this
 * conversation.
 */
export interface Conversation {
    id: string;
    [k: string]: unknown;
}
/**
 * A custom tool that processes input using a specified format.
 *
 * Learn more about
 * [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
 */
export interface CustomTool {
    name: string;
    type: 'custom';
    description?: string;
    /**
     * Unconstrained free-form text.
     */
    format?: CustomTool.Text | CustomTool.Grammar;
    [k: string]: unknown;
}
export declare namespace CustomTool {
    /**
     * Unconstrained free-form text.
     */
    interface Text {
        type: 'text';
        [k: string]: unknown;
    }
    /**
     * A grammar defined by the user.
     */
    interface Grammar {
        definition: string;
        syntax: 'lark' | 'regex';
        type: 'grammar';
        [k: string]: unknown;
    }
}
/**
 * A message input to the model with a role indicating instruction following
 * hierarchy. Instructions given with the `developer` or `system` role take
 * precedence over instructions given with the `user` role. Messages with the
 * `assistant` role are presumed to have been generated by the model in previous
 * interactions.
 */
export interface EasyInputMessage {
    content: string | Array<OpenAIResponseInputText | OpenAIResponseInputImage | OpenAIResponseInputFile>;
    role: 'user' | 'assistant' | 'system' | 'developer';
    phase?: 'commentary' | 'final_answer';
    type?: 'message';
    [k: string]: unknown;
}
/**
 * A tool that searches for relevant content from uploaded files.
 *
 * Learn more about the
 * [file search tool](https://platform.openai.com/docs/guides/tools-file-search).
 */
export interface FileSearchTool {
    type: 'file_search';
    vector_store_ids: Array<string>;
    /**
     * A filter used to compare a specified attribute key to a given value using a
     * defined comparison operation.
     */
    filters?: FileSearchTool.ComparisonFilter | FileSearchTool.CompoundFilter;
    max_num_results?: number;
    /**
     * Ranking options for search.
     */
    ranking_options?: FileSearchTool.RankingOptions;
    [k: string]: unknown;
}
export declare namespace FileSearchTool {
    /**
     * A filter used to compare a specified attribute key to a given value using a
     * defined comparison operation.
     */
    interface ComparisonFilter {
        key: string;
        type: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
        value: string | number | boolean | Array<string | number>;
        [k: string]: unknown;
    }
    /**
     * Combine multiple filters using `and` or `or`.
     */
    interface CompoundFilter {
        filters: Array<CompoundFilter.ComparisonFilter | unknown>;
        type: 'and' | 'or';
        [k: string]: unknown;
    }
    namespace CompoundFilter {
        /**
         * A filter used to compare a specified attribute key to a given value using a
         * defined comparison operation.
         */
        interface ComparisonFilter {
            key: string;
            type: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
            value: string | number | boolean | Array<string | number>;
            [k: string]: unknown;
        }
    }
    /**
     * Ranking options for search.
     */
    interface RankingOptions {
        /**
         * Weights that control how reciprocal rank fusion balances semantic embedding
         * matches versus sparse keyword matches when hybrid search is enabled.
         */
        hybrid_search?: RankingOptions.HybridSearch;
        ranker?: 'auto' | 'default-2024-11-15';
        score_threshold?: number;
        [k: string]: unknown;
    }
    namespace RankingOptions {
        /**
         * Weights that control how reciprocal rank fusion balances semantic embedding
         * matches versus sparse keyword matches when hybrid search is enabled.
         */
        interface HybridSearch {
            embedding_weight: number;
            text_weight: number;
            [k: string]: unknown;
        }
    }
}
/**
 * A tool that allows the model to execute shell commands.
 */
export interface FunctionShellTool {
    type: 'shell';
    environment?: FunctionShellTool.ContainerAuto | LocalEnvironment | ContainerReference;
    [k: string]: unknown;
}
export declare namespace FunctionShellTool {
    interface ContainerAuto {
        type: 'container_auto';
        file_ids?: Array<string>;
        memory_limit?: '1g' | '4g' | '16g' | '64g';
        network_policy?: ResponsesAPI.ContainerNetworkPolicyDisabled | ResponsesAPI.ContainerNetworkPolicyAllowlist;
        skills?: Array<ContainerAuto.SkillReference | ContainerAuto.InlineSkill>;
        [k: string]: unknown;
    }
    namespace ContainerAuto {
        interface SkillReference {
            skill_id: string;
            type: 'skill_reference';
            version?: string;
            [k: string]: unknown;
        }
        interface InlineSkill {
            description: string;
            name: string;
            /**
             * Inline skill payload
             */
            source: InlineSkill.Source;
            type: 'inline';
            [k: string]: unknown;
        }
        namespace InlineSkill {
            /**
             * Inline skill payload
             */
            interface Source {
                data: string;
                media_type: 'application/zip';
                type: 'base64';
                [k: string]: unknown;
            }
        }
    }
}
/**
 * Defines a function in your own code the model can choose to call.
 *
 * Learn more about
 * [function calling](https://platform.openai.com/docs/guides/function-calling).
 */
export interface FunctionTool {
    name: string;
    type: 'function';
    description?: string;
    parameters?: {
        [key: string]: unknown;
    };
    strict?: boolean;
    [k: string]: unknown;
}
/**
 * Details about why the response is incomplete.
 */
export interface IncompleteDetails {
    reason?: 'max_output_tokens' | 'content_filter';
    [k: string]: unknown;
}
export interface LocalEnvironment {
    type: 'local';
    skills?: Array<LocalEnvironment.Skill>;
    [k: string]: unknown;
}
export declare namespace LocalEnvironment {
    interface Skill {
        description: string;
        name: string;
        path: string;
        [k: string]: unknown;
    }
}
export interface LocalEnvironmentParam {
    type: 'local';
    skills?: Array<LocalEnvironmentParam.Skill>;
    [k: string]: unknown;
}
export declare namespace LocalEnvironmentParam {
    interface Skill {
        description: string;
        name: string;
        path: string;
        [k: string]: unknown;
    }
}
/**
 * A request for human approval of a tool invocation.
 */
export interface McpApprovalRequest {
    id: string;
    arguments: string;
    name: string;
    server_label: string;
    type: 'mcp_approval_request';
    [k: string]: unknown;
}
export interface OpenAIResponse {
    id: string;
    created_at: number;
    model: 'gpt-5.2' | 'gpt-5.2-2025-12-11' | 'gpt-5.2-chat-latest' | 'gpt-5.2-pro' | 'gpt-5.2-pro-2025-12-11' | 'gpt-5.1' | 'gpt-5.1-2025-11-13' | 'gpt-5.1-codex' | 'gpt-5.1-mini' | 'gpt-5.1-chat-latest' | 'gpt-5' | 'gpt-5-mini' | 'gpt-5-nano' | 'gpt-5-2025-08-07' | 'gpt-5-mini-2025-08-07' | 'gpt-5-nano-2025-08-07' | 'gpt-5-chat-latest' | 'gpt-4.1' | 'gpt-4.1-mini' | 'gpt-4.1-nano' | 'gpt-4.1-2025-04-14' | 'gpt-4.1-mini-2025-04-14' | 'gpt-4.1-nano-2025-04-14' | 'o4-mini' | 'o4-mini-2025-04-16' | 'o3' | 'o3-2025-04-16' | 'o3-mini' | 'o3-mini-2025-01-31' | 'o1' | 'o1-2024-12-17' | 'o1-preview' | 'o1-preview-2024-09-12' | 'o1-mini' | 'o1-mini-2024-09-12' | 'gpt-4o' | 'gpt-4o-2024-11-20' | 'gpt-4o-2024-08-06' | 'gpt-4o-2024-05-13' | 'gpt-4o-audio-preview' | 'gpt-4o-audio-preview-2024-10-01' | 'gpt-4o-audio-preview-2024-12-17' | 'gpt-4o-audio-preview-2025-06-03' | 'gpt-4o-mini-audio-preview' | 'gpt-4o-mini-audio-preview-2024-12-17' | 'gpt-4o-search-preview' | 'gpt-4o-mini-search-preview' | 'gpt-4o-search-preview-2025-03-11' | 'gpt-4o-mini-search-preview-2025-03-11' | 'chatgpt-4o-latest' | 'codex-mini-latest' | 'gpt-4o-mini' | 'gpt-4o-mini-2024-07-18' | 'gpt-4-turbo' | 'gpt-4-turbo-2024-04-09' | 'gpt-4-0125-preview' | 'gpt-4-turbo-preview' | 'gpt-4-1106-preview' | 'gpt-4-vision-preview' | 'gpt-4' | 'gpt-4-0314' | 'gpt-4-0613' | 'gpt-4-32k' | 'gpt-4-32k-0314' | 'gpt-4-32k-0613' | 'gpt-3.5-turbo' | 'gpt-3.5-turbo-16k' | 'gpt-3.5-turbo-0301' | 'gpt-3.5-turbo-0613' | 'gpt-3.5-turbo-1106' | 'gpt-3.5-turbo-0125' | 'gpt-3.5-turbo-16k-0613' | 'o1-pro' | 'o1-pro-2025-03-19' | 'o3-pro' | 'o3-pro-2025-06-10' | 'o3-deep-research' | 'o3-deep-research-2025-06-26' | 'o4-mini-deep-research' | 'o4-mini-deep-research-2025-06-26' | 'computer-use-preview' | 'computer-use-preview-2025-03-11' | 'gpt-5-codex' | 'gpt-5-pro' | 'gpt-5-pro-2025-10-06' | 'gpt-5.1-codex-max' | (string & {});
    object: 'response';
    output: Array<OpenAIResponseOutputMessage | OpenAIResponseFileSearchToolCall | OpenAIResponseFunctionToolCall | OpenAIResponseFunctionWebSearch | OpenAIResponseComputerToolCall | OpenAIResponseReasoningItem | ResponseCompactionItem | OpenAITypesResponsesResponseOutputItemImageGenerationCall | OpenAIResponseCodeInterpreterToolCall | OpenAITypesResponsesResponseOutputItemLocalShellCall | ResponseFunctionShellToolCall | ResponseFunctionShellToolCallOutput | ResponseApplyPatchToolCall | ResponseApplyPatchToolCallOutput | OpenAITypesResponsesResponseOutputItemMcpCall | OpenAITypesResponsesResponseOutputItemMcpListTools | McpApprovalRequest | OpenAIResponseCustomToolCall>;
    parallel_tool_calls: boolean;
    /**
     * Constrains the tools available to the model to a pre-defined set.
     */
    tool_choice: 'none' | 'auto' | 'required' | ToolChoiceAllowed | ToolChoiceTypes | ToolChoiceFunction | ToolChoiceMcp | ToolChoiceCustom | ToolChoiceApplyPatch | ToolChoiceShell;
    tools: Array<FunctionTool | FileSearchTool | ComputerTool | WebSearchTool | OpenAIResponse.Mcp | OpenAIResponse.CodeInterpreter | OpenAIResponse.ImageGeneration | OpenAIResponse.LocalShell | FunctionShellTool | CustomTool | WebSearchPreviewTool | ApplyPatchTool>;
    background?: boolean;
    completed_at?: number;
    /**
     * The conversation that this response belonged to.
     *
     * Input items and output items from this response were automatically added to this
     * conversation.
     */
    conversation?: Conversation;
    /**
     * An error object returned when the model fails to generate a Response.
     */
    error?: OpenAIResponseError;
    /**
     * Details about why the response is incomplete.
     */
    incomplete_details?: IncompleteDetails;
    instructions?: string | Array<EasyInputMessage | OpenAITypesResponsesResponseInputItemMessage | OpenAIResponseOutputMessage | OpenAIResponseFileSearchToolCall | OpenAIResponseComputerToolCall | OpenAITypesResponsesResponseInputItemComputerCallOutput | OpenAIResponseFunctionWebSearch | OpenAIResponseFunctionToolCall | OpenAITypesResponsesResponseInputItemFunctionCallOutput | OpenAIResponseReasoningItem | ResponseCompactionItemParam | OpenAITypesResponsesResponseInputItemImageGenerationCall | OpenAIResponseCodeInterpreterToolCall | OpenAITypesResponsesResponseInputItemLocalShellCall | OpenAITypesResponsesResponseInputItemLocalShellCallOutput | ShellCall | ShellCallOutput | ApplyPatchCall | ApplyPatchCallOutput | OpenAITypesResponsesResponseInputItemMcpListTools | McpApprovalRequest | OpenAITypesResponsesResponseInputItemMcpApprovalResponse | OpenAITypesResponsesResponseInputItemMcpCall | OpenAIResponseCustomToolCallOutput | OpenAIResponseCustomToolCall | OpenAITypesResponsesResponseInputItemItemReference>;
    max_output_tokens?: number;
    max_tool_calls?: number;
    metadata?: {
        [key: string]: string;
    };
    previous_response_id?: string;
    /**
     * Reference to a prompt template and its variables.
     * [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
     */
    prompt?: OpenAIResponsePrompt;
    prompt_cache_key?: string;
    prompt_cache_retention?: 'in-memory' | '24h';
    /**
     * **gpt-5 and o-series models only**
     *
     * Configuration options for
     * [reasoning models](https://platform.openai.com/docs/guides/reasoning).
     */
    reasoning?: Reasoning;
    safety_identifier?: string;
    service_tier?: 'auto' | 'default' | 'flex' | 'scale' | 'priority';
    status?: 'completed' | 'failed' | 'in_progress' | 'cancelled' | 'queued' | 'incomplete';
    temperature?: number;
    /**
     * Configuration options for a text response from the model.
     *
     * Can be plain text or structured JSON data. Learn more:
     *
     * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
     * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
     */
    text?: OpenAIResponseTextConfig;
    top_logprobs?: number;
    top_p?: number;
    truncation?: 'auto' | 'disabled';
    /**
     * Represents token usage details including input tokens, output tokens, a
     * breakdown of output tokens, and the total tokens used.
     */
    usage?: OpenAIResponseUsage;
    user?: string;
    [k: string]: unknown;
}
export declare namespace OpenAIResponse {
    /**
     * Give the model access to additional tools via remote Model Context Protocol
     * (MCP) servers.
     * [Learn more about MCP](https://platform.openai.com/docs/guides/tools-remote-mcp).
     */
    interface Mcp {
        server_label: string;
        type: 'mcp';
        /**
         * A filter object to specify which tools are allowed.
         */
        allowed_tools?: Array<string> | Mcp.McpAllowedToolsMcpToolFilter;
        authorization?: string;
        connector_id?: 'connector_dropbox' | 'connector_gmail' | 'connector_googlecalendar' | 'connector_googledrive' | 'connector_microsoftteams' | 'connector_outlookcalendar' | 'connector_outlookemail' | 'connector_sharepoint';
        headers?: {
            [key: string]: string;
        };
        /**
         * Specify which of the MCP server's tools require approval.
         *
         * Can be `always`, `never`, or a filter object associated with tools that require
         * approval.
         */
        require_approval?: Mcp.McpRequireApprovalMcpToolApprovalFilter | 'always' | 'never';
        server_description?: string;
        server_url?: string;
        [k: string]: unknown;
    }
    namespace Mcp {
        /**
         * A filter object to specify which tools are allowed.
         */
        interface McpAllowedToolsMcpToolFilter {
            read_only?: boolean;
            tool_names?: Array<string>;
            [k: string]: unknown;
        }
        /**
         * Specify which of the MCP server's tools require approval.
         *
         * Can be `always`, `never`, or a filter object associated with tools that require
         * approval.
         */
        interface McpRequireApprovalMcpToolApprovalFilter {
            /**
             * A filter object to specify which tools are allowed.
             */
            always?: McpRequireApprovalMcpToolApprovalFilter.Always;
            /**
             * A filter object to specify which tools are allowed.
             */
            never?: McpRequireApprovalMcpToolApprovalFilter.Never;
            [k: string]: unknown;
        }
        namespace McpRequireApprovalMcpToolApprovalFilter {
            /**
             * A filter object to specify which tools are allowed.
             */
            interface Always {
                read_only?: boolean;
                tool_names?: Array<string>;
                [k: string]: unknown;
            }
            /**
             * A filter object to specify which tools are allowed.
             */
            interface Never {
                read_only?: boolean;
                tool_names?: Array<string>;
                [k: string]: unknown;
            }
        }
    }
    /**
     * A tool that runs Python code to help generate a response to a prompt.
     */
    interface CodeInterpreter {
        /**
         * Configuration for a code interpreter container.
         *
         * Optionally specify the IDs of the files to run the code on.
         */
        container: string | CodeInterpreter.CodeInterpreterContainerCodeInterpreterToolAuto;
        type: 'code_interpreter';
        [k: string]: unknown;
    }
    namespace CodeInterpreter {
        /**
         * Configuration for a code interpreter container.
         *
         * Optionally specify the IDs of the files to run the code on.
         */
        interface CodeInterpreterContainerCodeInterpreterToolAuto {
            type: 'auto';
            file_ids?: Array<string>;
            memory_limit?: '1g' | '4g' | '16g' | '64g';
            network_policy?: ResponsesAPI.ContainerNetworkPolicyDisabled | ResponsesAPI.ContainerNetworkPolicyAllowlist;
            [k: string]: unknown;
        }
    }
    /**
     * A tool that generates images using the GPT image models.
     */
    interface ImageGeneration {
        type: 'image_generation';
        action?: 'generate' | 'edit' | 'auto';
        background?: 'transparent' | 'opaque' | 'auto';
        input_fidelity?: 'high' | 'low';
        /**
         * Optional mask for inpainting.
         *
         * Contains `image_url` (string, optional) and `file_id` (string, optional).
         */
        input_image_mask?: ImageGeneration.InputImageMask;
        model?: (string & {}) | 'gpt-image-1' | 'gpt-image-1-mini' | 'gpt-image-1.5';
        moderation?: 'auto' | 'low';
        output_compression?: number;
        output_format?: 'png' | 'webp' | 'jpeg';
        partial_images?: number;
        quality?: 'low' | 'medium' | 'high' | 'auto';
        size?: '1024x1024' | '1024x1536' | '1536x1024' | 'auto';
        [k: string]: unknown;
    }
    namespace ImageGeneration {
        /**
         * Optional mask for inpainting.
         *
         * Contains `image_url` (string, optional) and `file_id` (string, optional).
         */
        interface InputImageMask {
            file_id?: string;
            image_url?: string;
            [k: string]: unknown;
        }
    }
    /**
     * A tool that allows the model to execute shell commands in a local environment.
     */
    interface LocalShell {
        type: 'local_shell';
        [k: string]: unknown;
    }
}
/**
 * A tool call to run code.
 */
export interface OpenAIResponseCodeInterpreterToolCall {
    id: string;
    container_id: string;
    status: 'in_progress' | 'completed' | 'incomplete' | 'interpreting' | 'failed';
    type: 'code_interpreter_call';
    code?: string;
    outputs?: Array<OpenAIResponseCodeInterpreterToolCall.OutputLogs | OpenAIResponseCodeInterpreterToolCall.OutputImage>;
    [k: string]: unknown;
}
export declare namespace OpenAIResponseCodeInterpreterToolCall {
    /**
     * The logs output from the code interpreter.
     */
    interface OutputLogs {
        logs: string;
        type: 'logs';
        [k: string]: unknown;
    }
    /**
     * The image output from the code interpreter.
     */
    interface OutputImage {
        type: 'image';
        url: string;
        [k: string]: unknown;
    }
}
/**
 * A tool call to a computer use tool.
 *
 * See the
 * [computer use guide](https://platform.openai.com/docs/guides/tools-computer-use)
 * for more information.
 */
export interface OpenAIResponseComputerToolCall {
    id: string;
    /**
     * A click action.
     */
    action: OpenAIResponseComputerToolCall.ActionClick | OpenAIResponseComputerToolCall.ActionDoubleClick | OpenAIResponseComputerToolCall.ActionDrag | OpenAIResponseComputerToolCall.ActionKeypress | OpenAIResponseComputerToolCall.ActionMove | OpenAIResponseComputerToolCall.ActionScreenshot | OpenAIResponseComputerToolCall.ActionScroll | OpenAIResponseComputerToolCall.ActionType | OpenAIResponseComputerToolCall.ActionWait;
    call_id: string;
    pending_safety_checks: Array<OpenAIResponseComputerToolCall.PendingSafetyCheck>;
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'computer_call';
    [k: string]: unknown;
}
export declare namespace OpenAIResponseComputerToolCall {
    /**
     * A click action.
     */
    interface ActionClick {
        button: 'left' | 'right' | 'wheel' | 'back' | 'forward';
        type: 'click';
        x: number;
        y: number;
        [k: string]: unknown;
    }
    /**
     * A double click action.
     */
    interface ActionDoubleClick {
        type: 'double_click';
        x: number;
        y: number;
        [k: string]: unknown;
    }
    /**
     * A drag action.
     */
    interface ActionDrag {
        path: Array<ActionDrag.Path>;
        type: 'drag';
        [k: string]: unknown;
    }
    namespace ActionDrag {
        /**
         * An x/y coordinate pair, e.g. `{ x: 100, y: 200 }`.
         */
        interface Path {
            x: number;
            y: number;
            [k: string]: unknown;
        }
    }
    /**
     * A collection of keypresses the model would like to perform.
     */
    interface ActionKeypress {
        keys: Array<string>;
        type: 'keypress';
        [k: string]: unknown;
    }
    /**
     * A mouse move action.
     */
    interface ActionMove {
        type: 'move';
        x: number;
        y: number;
        [k: string]: unknown;
    }
    /**
     * A screenshot action.
     */
    interface ActionScreenshot {
        type: 'screenshot';
        [k: string]: unknown;
    }
    /**
     * A scroll action.
     */
    interface ActionScroll {
        scroll_x: number;
        scroll_y: number;
        type: 'scroll';
        x: number;
        y: number;
        [k: string]: unknown;
    }
    /**
     * An action to type in text.
     */
    interface ActionType {
        text: string;
        type: 'type';
        [k: string]: unknown;
    }
    /**
     * A wait action.
     */
    interface ActionWait {
        type: 'wait';
        [k: string]: unknown;
    }
    /**
     * A pending safety check for the computer call.
     */
    interface PendingSafetyCheck {
        id: string;
        code?: string;
        message?: string;
        [k: string]: unknown;
    }
}
/**
 * A call to a custom tool created by the model.
 */
export interface OpenAIResponseCustomToolCall {
    call_id: string;
    input: string;
    name: string;
    type: 'custom_tool_call';
    id?: string;
    [k: string]: unknown;
}
/**
 * The output of a custom tool call from your code, being sent back to the model.
 */
export interface OpenAIResponseCustomToolCallOutput {
    call_id: string;
    output: string | Array<OpenAIResponseInputText | OpenAIResponseInputImage | OpenAIResponseInputFile>;
    type: 'custom_tool_call_output';
    id?: string;
    [k: string]: unknown;
}
/**
 * An error object returned when the model fails to generate a Response.
 */
export interface OpenAIResponseError {
    code: 'server_error' | 'rate_limit_exceeded' | 'invalid_prompt' | 'vector_store_timeout' | 'invalid_image' | 'invalid_image_format' | 'invalid_base64_image' | 'invalid_image_url' | 'image_too_large' | 'image_too_small' | 'image_parse_error' | 'image_content_policy_violation' | 'invalid_image_mode' | 'image_file_too_large' | 'unsupported_image_media_type' | 'empty_image_file' | 'failed_to_download_image' | 'image_file_not_found';
    message: string;
    [k: string]: unknown;
}
/**
 * The results of a file search tool call.
 *
 * See the
 * [file search guide](https://platform.openai.com/docs/guides/tools-file-search)
 * for more information.
 */
export interface OpenAIResponseFileSearchToolCall {
    id: string;
    queries: Array<string>;
    status: 'in_progress' | 'searching' | 'completed' | 'incomplete' | 'failed';
    type: 'file_search_call';
    results?: Array<OpenAIResponseFileSearchToolCall.Result>;
    [k: string]: unknown;
}
export declare namespace OpenAIResponseFileSearchToolCall {
    interface Result {
        attributes?: {
            [key: string]: string | number | boolean;
        };
        file_id?: string;
        filename?: string;
        score?: number;
        text?: string;
        [k: string]: unknown;
    }
}
/**
 * A tool call to run a function.
 *
 * See the
 * [function calling guide](https://platform.openai.com/docs/guides/function-calling)
 * for more information.
 */
export interface OpenAIResponseFunctionToolCall {
    arguments: string;
    call_id: string;
    name: string;
    type: 'function_call';
    id?: string;
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
/**
 * The results of a web search tool call.
 *
 * See the
 * [web search guide](https://platform.openai.com/docs/guides/tools-web-search) for
 * more information.
 */
export interface OpenAIResponseFunctionWebSearch {
    id: string;
    /**
     * Action type "search" - Performs a web search query.
     */
    action: OpenAIResponseFunctionWebSearch.OpenAITypesResponsesResponseFunctionWebSearchActionSearch | OpenAIResponseFunctionWebSearch.OpenAITypesResponsesResponseFunctionWebSearchActionOpenPage | OpenAIResponseFunctionWebSearch.ActionFind;
    status: 'in_progress' | 'searching' | 'completed' | 'failed';
    type: 'web_search_call';
    [k: string]: unknown;
}
export declare namespace OpenAIResponseFunctionWebSearch {
    /**
     * Action type "search" - Performs a web search query.
     */
    interface OpenAITypesResponsesResponseFunctionWebSearchActionSearch {
        query: string;
        type: 'search';
        queries?: Array<string>;
        sources?: Array<OpenAITypesResponsesResponseFunctionWebSearchActionSearch.Source>;
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseFunctionWebSearchActionSearch {
        /**
         * A source used in the search.
         */
        interface Source {
            type: 'url';
            url: string;
            [k: string]: unknown;
        }
    }
    /**
     * Action type "open_page" - Opens a specific URL from search results.
     */
    interface OpenAITypesResponsesResponseFunctionWebSearchActionOpenPage {
        type: 'open_page';
        url?: string;
        [k: string]: unknown;
    }
    /**
     * Action type "find_in_page": Searches for a pattern within a loaded page.
     */
    interface ActionFind {
        pattern: string;
        type: 'find_in_page';
        url: string;
        [k: string]: unknown;
    }
}
/**
 * A file input to the model.
 */
export interface OpenAIResponseInputFile {
    type: 'input_file';
    file_data?: string;
    file_id?: string;
    file_url?: string;
    filename?: string;
    [k: string]: unknown;
}
/**
 * A file input to the model.
 */
export interface OpenAIResponseInputFileParam {
    type: 'input_file';
    file_data?: string;
    file_id?: string;
    file_url?: string;
    filename?: string;
    [k: string]: unknown;
}
/**
 * An image input to the model.
 *
 * Learn about [image inputs](https://platform.openai.com/docs/guides/vision).
 */
export interface OpenAIResponseInputImage {
    detail: 'low' | 'high' | 'auto';
    type: 'input_image';
    file_id?: string;
    image_url?: string;
    [k: string]: unknown;
}
/**
 * An image input to the model.
 *
 * Learn about [image inputs](https://platform.openai.com/docs/guides/vision).
 */
export interface OpenAIResponseInputImageParam {
    detail: 'low' | 'high' | 'auto';
    type: 'input_image';
    file_id?: string;
    image_url?: string;
    [k: string]: unknown;
}
/**
 * A text input to the model.
 */
export interface OpenAIResponseInputText {
    text: string;
    type: 'input_text';
    [k: string]: unknown;
}
/**
 * A text input to the model.
 */
export interface OpenAIResponseInputTextParam {
    text: string;
    type: 'input_text';
    [k: string]: unknown;
}
/**
 * An output message from the model.
 */
export interface OpenAIResponseOutputMessage {
    id: string;
    content: Array<OpenAIResponseOutputText | OpenAIResponseOutputRefusal>;
    role: 'assistant';
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'message';
    phase?: 'commentary' | 'final_answer';
    [k: string]: unknown;
}
/**
 * A refusal from the model.
 */
export interface OpenAIResponseOutputRefusal {
    refusal: string;
    type: 'refusal';
    [k: string]: unknown;
}
/**
 * A text output from the model.
 */
export interface OpenAIResponseOutputText {
    annotations: Array<OpenAIResponseOutputText.AnnotationFileCitation | OpenAIResponseOutputText.OpenAITypesResponsesResponseOutputTextAnnotationURLCitation | OpenAIResponseOutputText.AnnotationContainerFileCitation | OpenAIResponseOutputText.AnnotationFilePath>;
    text: string;
    type: 'output_text';
    logprobs?: Array<OpenAIResponseOutputText.Logprob>;
    [k: string]: unknown;
}
export declare namespace OpenAIResponseOutputText {
    /**
     * A citation to a file.
     */
    interface AnnotationFileCitation {
        file_id: string;
        filename: string;
        index: number;
        type: 'file_citation';
        [k: string]: unknown;
    }
    /**
     * A citation for a web resource used to generate a model response.
     */
    interface OpenAITypesResponsesResponseOutputTextAnnotationURLCitation {
        end_index: number;
        start_index: number;
        title: string;
        type: 'url_citation';
        url: string;
        [k: string]: unknown;
    }
    /**
     * A citation for a container file used to generate a model response.
     */
    interface AnnotationContainerFileCitation {
        container_id: string;
        end_index: number;
        file_id: string;
        filename: string;
        start_index: number;
        type: 'container_file_citation';
        [k: string]: unknown;
    }
    /**
     * A path to a file.
     */
    interface AnnotationFilePath {
        file_id: string;
        index: number;
        type: 'file_path';
        [k: string]: unknown;
    }
    /**
     * The log probability of a token.
     */
    interface Logprob {
        token: string;
        bytes: Array<number>;
        logprob: number;
        top_logprobs: Array<Logprob.TopLogprob>;
        [k: string]: unknown;
    }
    namespace Logprob {
        /**
         * The top log probability of a token.
         */
        interface TopLogprob {
            token: string;
            bytes: Array<number>;
            logprob: number;
            [k: string]: unknown;
        }
    }
}
/**
 * Reference to a prompt template and its variables.
 * [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
 */
export interface OpenAIResponsePrompt {
    id: string;
    variables?: {
        [key: string]: string | OpenAIResponseInputText | OpenAIResponseInputImage | OpenAIResponseInputFile;
    };
    version?: string;
    [k: string]: unknown;
}
/**
 * A description of the chain of thought used by a reasoning model while generating
 * a response. Be sure to include these items in your `input` to the Responses API
 * for subsequent turns of a conversation if you are manually
 * [managing context](https://platform.openai.com/docs/guides/conversation-state).
 */
export interface OpenAIResponseReasoningItem {
    id: string;
    summary: Array<OpenAIResponseReasoningItem.Summary>;
    type: 'reasoning';
    content?: Array<OpenAIResponseReasoningItem.Content>;
    encrypted_content?: string;
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
export declare namespace OpenAIResponseReasoningItem {
    /**
     * A summary text from the model.
     */
    interface Summary {
        text: string;
        type: 'summary_text';
        [k: string]: unknown;
    }
    /**
     * Reasoning text from the model.
     */
    interface Content {
        text: string;
        type: 'reasoning_text';
        [k: string]: unknown;
    }
}
/**
 * Configuration options for a text response from the model.
 *
 * Can be plain text or structured JSON data. Learn more:
 *
 * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
 * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
 */
export interface OpenAIResponseTextConfig {
    /**
     * Default response format. Used to generate text responses.
     */
    format?: OpenAIResponseTextConfig.ResponseFormatText | OpenAIResponseTextConfig.ResponseFormatTextJsonSchemaConfig | OpenAIResponseTextConfig.ResponseFormatJsonObject;
    verbosity?: 'low' | 'medium' | 'high';
    [k: string]: unknown;
}
export declare namespace OpenAIResponseTextConfig {
    /**
     * Default response format. Used to generate text responses.
     */
    interface ResponseFormatText {
        type: 'text';
        [k: string]: unknown;
    }
    /**
     * JSON Schema response format.
     *
     * Used to generate structured JSON responses. Learn more about
     * [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs).
     */
    interface ResponseFormatTextJsonSchemaConfig {
        name: string;
        schema: {
            [key: string]: unknown;
        };
        type: 'json_schema';
        description?: string;
        strict?: boolean;
        [k: string]: unknown;
    }
    /**
     * JSON object response format.
     *
     * An older method of generating JSON responses. Using `json_schema` is recommended
     * for models that support it. Note that the model will not generate JSON without a
     * system or user message instructing it to do so.
     */
    interface ResponseFormatJsonObject {
        type: 'json_object';
        [k: string]: unknown;
    }
}
/**
 * Represents token usage details including input tokens, output tokens, a
 * breakdown of output tokens, and the total tokens used.
 */
export interface OpenAIResponseUsage {
    input_tokens: number;
    /**
     * A detailed breakdown of the input tokens.
     */
    input_tokens_details: OpenAIResponseUsage.InputTokensDetails;
    output_tokens: number;
    /**
     * A detailed breakdown of the output tokens.
     */
    output_tokens_details: OpenAIResponseUsage.OutputTokensDetails;
    total_tokens: number;
    [k: string]: unknown;
}
export declare namespace OpenAIResponseUsage {
    /**
     * A detailed breakdown of the input tokens.
     */
    interface InputTokensDetails {
        cached_tokens: number;
        [k: string]: unknown;
    }
    /**
     * A detailed breakdown of the output tokens.
     */
    interface OutputTokensDetails {
        reasoning_tokens: number;
        [k: string]: unknown;
    }
}
/**
 * The output of a computer tool call.
 */
export interface OpenAITypesResponsesResponseInputItemComputerCallOutput {
    call_id: string;
    /**
     * A computer screenshot image used with the computer use tool.
     */
    output: ResponseComputerToolCallOutputScreenshot;
    type: 'computer_call_output';
    id?: string;
    acknowledged_safety_checks?: Array<OpenAITypesResponsesResponseInputItemComputerCallOutput.AcknowledgedSafetyCheck>;
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
export declare namespace OpenAITypesResponsesResponseInputItemComputerCallOutput {
    /**
     * A pending safety check for the computer call.
     */
    interface AcknowledgedSafetyCheck {
        id: string;
        code?: string;
        message?: string;
        [k: string]: unknown;
    }
}
/**
 * The output of a function tool call.
 */
export interface OpenAITypesResponsesResponseInputItemFunctionCallOutput {
    call_id: string;
    output: string | Array<OpenAITypesResponsesResponseInputItemFunctionCallOutput.ResponseInputTextContent | OpenAITypesResponsesResponseInputItemFunctionCallOutput.ResponseInputImageContent | OpenAITypesResponsesResponseInputItemFunctionCallOutput.ResponseInputFileContent>;
    type: 'function_call_output';
    id?: string;
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
export declare namespace OpenAITypesResponsesResponseInputItemFunctionCallOutput {
    /**
     * A text input to the model.
     */
    interface ResponseInputTextContent {
        text: string;
        type: 'input_text';
        [k: string]: unknown;
    }
    /**
     * An image input to the model.
     *
     * Learn about [image inputs](https://platform.openai.com/docs/guides/vision)
     */
    interface ResponseInputImageContent {
        type: 'input_image';
        detail?: 'low' | 'high' | 'auto';
        file_id?: string;
        image_url?: string;
        [k: string]: unknown;
    }
    /**
     * A file input to the model.
     */
    interface ResponseInputFileContent {
        type: 'input_file';
        file_data?: string;
        file_id?: string;
        file_url?: string;
        filename?: string;
        [k: string]: unknown;
    }
}
/**
 * An image generation request made by the model.
 */
export interface OpenAITypesResponsesResponseInputItemImageGenerationCall {
    id: string;
    status: 'in_progress' | 'completed' | 'generating' | 'failed';
    type: 'image_generation_call';
    result?: string;
    [k: string]: unknown;
}
/**
 * An internal identifier for an item to reference.
 */
export interface OpenAITypesResponsesResponseInputItemItemReference {
    id: string;
    type?: 'item_reference';
    [k: string]: unknown;
}
/**
 * A tool call to run a command on the local shell.
 */
export interface OpenAITypesResponsesResponseInputItemLocalShellCall {
    id: string;
    /**
     * Execute a shell command on the server.
     */
    action: OpenAITypesResponsesResponseInputItemLocalShellCall.Action;
    call_id: string;
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'local_shell_call';
    [k: string]: unknown;
}
export declare namespace OpenAITypesResponsesResponseInputItemLocalShellCall {
    /**
     * Execute a shell command on the server.
     */
    interface Action {
        command: Array<string>;
        env: {
            [key: string]: string;
        };
        type: 'exec';
        timeout_ms?: number;
        user?: string;
        working_directory?: string;
        [k: string]: unknown;
    }
}
/**
 * The output of a local shell tool call.
 */
export interface OpenAITypesResponsesResponseInputItemLocalShellCallOutput {
    id: string;
    output: string;
    type: 'local_shell_call_output';
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
/**
 * A response to an MCP approval request.
 */
export interface OpenAITypesResponsesResponseInputItemMcpApprovalResponse {
    approval_request_id: string;
    approve: boolean;
    type: 'mcp_approval_response';
    id?: string;
    reason?: string;
    [k: string]: unknown;
}
/**
 * An invocation of a tool on an MCP server.
 */
export interface OpenAITypesResponsesResponseInputItemMcpCall {
    id: string;
    arguments: string;
    name: string;
    server_label: string;
    type: 'mcp_call';
    approval_request_id?: string;
    error?: string;
    output?: string;
    status?: 'in_progress' | 'completed' | 'incomplete' | 'calling' | 'failed';
    [k: string]: unknown;
}
/**
 * A list of tools available on an MCP server.
 */
export interface OpenAITypesResponsesResponseInputItemMcpListTools {
    id: string;
    server_label: string;
    tools: Array<OpenAITypesResponsesResponseInputItemMcpListTools.Tool>;
    type: 'mcp_list_tools';
    error?: string;
    [k: string]: unknown;
}
export declare namespace OpenAITypesResponsesResponseInputItemMcpListTools {
    /**
     * A tool available on an MCP server.
     */
    interface Tool {
        input_schema: unknown;
        name: string;
        annotations?: unknown;
        description?: string;
        [k: string]: unknown;
    }
}
/**
 * A message input to the model with a role indicating instruction following
 * hierarchy. Instructions given with the `developer` or `system` role take
 * precedence over instructions given with the `user` role.
 */
export interface OpenAITypesResponsesResponseInputItemMessage {
    content: Array<OpenAIResponseInputText | OpenAIResponseInputImage | OpenAIResponseInputFile>;
    role: 'user' | 'system' | 'developer';
    status?: 'in_progress' | 'completed' | 'incomplete';
    type?: 'message';
    [k: string]: unknown;
}
/**
 * An image generation request made by the model.
 */
export interface OpenAITypesResponsesResponseOutputItemImageGenerationCall {
    id: string;
    status: 'in_progress' | 'completed' | 'generating' | 'failed';
    type: 'image_generation_call';
    result?: string;
    [k: string]: unknown;
}
/**
 * A tool call to run a command on the local shell.
 */
export interface OpenAITypesResponsesResponseOutputItemLocalShellCall {
    id: string;
    /**
     * Execute a shell command on the server.
     */
    action: OpenAITypesResponsesResponseOutputItemLocalShellCall.Action;
    call_id: string;
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'local_shell_call';
    [k: string]: unknown;
}
export declare namespace OpenAITypesResponsesResponseOutputItemLocalShellCall {
    /**
     * Execute a shell command on the server.
     */
    interface Action {
        command: Array<string>;
        env: {
            [key: string]: string;
        };
        type: 'exec';
        timeout_ms?: number;
        user?: string;
        working_directory?: string;
        [k: string]: unknown;
    }
}
/**
 * An invocation of a tool on an MCP server.
 */
export interface OpenAITypesResponsesResponseOutputItemMcpCall {
    id: string;
    arguments: string;
    name: string;
    server_label: string;
    type: 'mcp_call';
    approval_request_id?: string;
    error?: string;
    output?: string;
    status?: 'in_progress' | 'completed' | 'incomplete' | 'calling' | 'failed';
    [k: string]: unknown;
}
/**
 * A list of tools available on an MCP server.
 */
export interface OpenAITypesResponsesResponseOutputItemMcpListTools {
    id: string;
    server_label: string;
    tools: Array<OpenAITypesResponsesResponseOutputItemMcpListTools.Tool>;
    type: 'mcp_list_tools';
    error?: string;
    [k: string]: unknown;
}
export declare namespace OpenAITypesResponsesResponseOutputItemMcpListTools {
    /**
     * A tool available on an MCP server.
     */
    interface Tool {
        input_schema: unknown;
        name: string;
        annotations?: unknown;
        description?: string;
        [k: string]: unknown;
    }
}
/**
 * Reasoning text from the model.
 */
export interface PartReasoningText {
    text: string;
    type: 'reasoning_text';
    [k: string]: unknown;
}
/**
 * **gpt-5 and o-series models only**
 *
 * Configuration options for
 * [reasoning models](https://platform.openai.com/docs/guides/reasoning).
 */
export interface Reasoning {
    effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
    generate_summary?: 'auto' | 'concise' | 'detailed';
    summary?: 'auto' | 'concise' | 'detailed';
    [k: string]: unknown;
}
/**
 * A tool call that applies file diffs by creating, deleting, or updating files.
 */
export interface ResponseApplyPatchToolCall {
    id: string;
    call_id: string;
    /**
     * Instruction describing how to create a file via the apply_patch tool.
     */
    operation: ResponseApplyPatchToolCall.OperationCreateFile | ResponseApplyPatchToolCall.OperationDeleteFile | ResponseApplyPatchToolCall.OperationUpdateFile;
    status: 'in_progress' | 'completed';
    type: 'apply_patch_call';
    created_by?: string;
    [k: string]: unknown;
}
export declare namespace ResponseApplyPatchToolCall {
    /**
     * Instruction describing how to create a file via the apply_patch tool.
     */
    interface OperationCreateFile {
        diff: string;
        path: string;
        type: 'create_file';
        [k: string]: unknown;
    }
    /**
     * Instruction describing how to delete a file via the apply_patch tool.
     */
    interface OperationDeleteFile {
        path: string;
        type: 'delete_file';
        [k: string]: unknown;
    }
    /**
     * Instruction describing how to update a file via the apply_patch tool.
     */
    interface OperationUpdateFile {
        diff: string;
        path: string;
        type: 'update_file';
        [k: string]: unknown;
    }
}
/**
 * The output emitted by an apply patch tool call.
 */
export interface ResponseApplyPatchToolCallOutput {
    id: string;
    call_id: string;
    status: 'completed' | 'failed';
    type: 'apply_patch_call_output';
    created_by?: string;
    output?: string;
    [k: string]: unknown;
}
/**
 * A compaction item generated by the
 * [`v1/responses/compact` API](https://platform.openai.com/docs/api-reference/responses/compact).
 */
export interface ResponseCompactionItem {
    id: string;
    encrypted_content: string;
    type: 'compaction';
    created_by?: string;
    [k: string]: unknown;
}
/**
 * A compaction item generated by the
 * [`v1/responses/compact` API](https://platform.openai.com/docs/api-reference/responses/compact).
 */
export interface ResponseCompactionItemParam {
    encrypted_content: string;
    type: 'compaction';
    id?: string;
    [k: string]: unknown;
}
/**
 * A computer screenshot image used with the computer use tool.
 */
export interface ResponseComputerToolCallOutputScreenshot {
    type: 'computer_screenshot';
    file_id?: string;
    image_url?: string;
    [k: string]: unknown;
}
/**
 * A tool call that executes one or more shell commands in a managed environment.
 */
export interface ResponseFunctionShellToolCall {
    id: string;
    /**
     * The shell commands and limits that describe how to run the tool call.
     */
    action: ResponseFunctionShellToolCall.Action;
    call_id: string;
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'shell_call';
    created_by?: string;
    /**
     * Represents the use of a local environment to perform shell actions.
     */
    environment?: ResponseFunctionShellToolCall.ResponseLocalEnvironment | ResponseFunctionShellToolCall.ResponseContainerReference;
    [k: string]: unknown;
}
export declare namespace ResponseFunctionShellToolCall {
    /**
     * The shell commands and limits that describe how to run the tool call.
     */
    interface Action {
        commands: Array<string>;
        max_output_length?: number;
        timeout_ms?: number;
        [k: string]: unknown;
    }
    /**
     * Represents the use of a local environment to perform shell actions.
     */
    interface ResponseLocalEnvironment {
        type: 'local';
        [k: string]: unknown;
    }
    /**
     * Represents a container created with /v1/containers.
     */
    interface ResponseContainerReference {
        container_id: string;
        type: 'container_reference';
        [k: string]: unknown;
    }
}
/**
 * The output of a shell tool call that was emitted.
 */
export interface ResponseFunctionShellToolCallOutput {
    id: string;
    call_id: string;
    output: Array<ResponseFunctionShellToolCallOutput.Output>;
    status: 'in_progress' | 'completed' | 'incomplete';
    type: 'shell_call_output';
    created_by?: string;
    max_output_length?: number;
    [k: string]: unknown;
}
export declare namespace ResponseFunctionShellToolCallOutput {
    /**
     * The content of a shell tool call output that was emitted.
     */
    interface Output {
        /**
         * Indicates that the shell call exceeded its configured time limit.
         */
        outcome: Output.OutputOutcomeTimeout | Output.OutputOutcomeExit;
        stderr: string;
        stdout: string;
        created_by?: string;
        [k: string]: unknown;
    }
    namespace Output {
        /**
         * Indicates that the shell call exceeded its configured time limit.
         */
        interface OutputOutcomeTimeout {
            type: 'timeout';
            [k: string]: unknown;
        }
        /**
         * Indicates that the shell commands finished and returned an exit code.
         */
        interface OutputOutcomeExit {
            exit_code: number;
            type: 'exit';
            [k: string]: unknown;
        }
    }
}
/**
 * A tool representing a request to execute one or more shell commands.
 */
export interface ShellCall {
    /**
     * The shell commands and limits that describe how to run the tool call.
     */
    action: ShellCall.Action;
    call_id: string;
    type: 'shell_call';
    id?: string;
    environment?: LocalEnvironment | ContainerReference;
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
export declare namespace ShellCall {
    /**
     * The shell commands and limits that describe how to run the tool call.
     */
    interface Action {
        commands: Array<string>;
        max_output_length?: number;
        timeout_ms?: number;
        [k: string]: unknown;
    }
}
/**
 * The streamed output items emitted by a shell tool call.
 */
export interface ShellCallOutput {
    call_id: string;
    output: Array<ShellCallOutput.Output>;
    type: 'shell_call_output';
    id?: string;
    max_output_length?: number;
    status?: 'in_progress' | 'completed' | 'incomplete';
    [k: string]: unknown;
}
export declare namespace ShellCallOutput {
    /**
     * Captured stdout and stderr for a portion of a shell tool call output.
     */
    interface Output {
        /**
         * Indicates that the shell call exceeded its configured time limit.
         */
        outcome: Output.OutcomeTimeout | Output.OutcomeExit;
        stderr: string;
        stdout: string;
        [k: string]: unknown;
    }
    namespace Output {
        /**
         * Indicates that the shell call exceeded its configured time limit.
         */
        interface OutcomeTimeout {
            type: 'timeout';
            [k: string]: unknown;
        }
        /**
         * Indicates that the shell commands finished and returned an exit code.
         */
        interface OutcomeExit {
            exit_code: number;
            type: 'exit';
            [k: string]: unknown;
        }
    }
}
/**
 * Constrains the tools available to the model to a pre-defined set.
 */
export interface ToolChoiceAllowed {
    mode: 'auto' | 'required';
    tools: Array<{
        [key: string]: unknown;
    }>;
    type: 'allowed_tools';
    [k: string]: unknown;
}
/**
 * Forces the model to call the apply_patch tool when executing a tool call.
 */
export interface ToolChoiceApplyPatch {
    type: 'apply_patch';
    [k: string]: unknown;
}
/**
 * Use this option to force the model to call a specific custom tool.
 */
export interface ToolChoiceCustom {
    name: string;
    type: 'custom';
    [k: string]: unknown;
}
/**
 * Use this option to force the model to call a specific function.
 */
export interface ToolChoiceFunction {
    name: string;
    type: 'function';
    [k: string]: unknown;
}
/**
 * Use this option to force the model to call a specific tool on a remote MCP
 * server.
 */
export interface ToolChoiceMcp {
    server_label: string;
    type: 'mcp';
    name?: string;
    [k: string]: unknown;
}
/**
 * Forces the model to call the shell tool when a tool call is required.
 */
export interface ToolChoiceShell {
    type: 'shell';
    [k: string]: unknown;
}
/**
 * Indicates that the model should use a built-in tool to generate a response.
 * [Learn more about built-in tools](https://platform.openai.com/docs/guides/tools).
 */
export interface ToolChoiceTypes {
    type: 'file_search' | 'web_search_preview' | 'computer_use_preview' | 'web_search_preview_2025_03_11' | 'image_generation' | 'code_interpreter';
    [k: string]: unknown;
}
/**
 * This tool searches the web for relevant results to use in a response.
 *
 * Learn more about the
 * [web search tool](https://platform.openai.com/docs/guides/tools-web-search).
 */
export interface WebSearchPreviewTool {
    type: 'web_search_preview' | 'web_search_preview_2025_03_11';
    search_context_size?: 'low' | 'medium' | 'high';
    /**
     * The user's location.
     */
    user_location?: WebSearchPreviewTool.UserLocation;
    [k: string]: unknown;
}
export declare namespace WebSearchPreviewTool {
    /**
     * The user's location.
     */
    interface UserLocation {
        type: 'approximate';
        city?: string;
        country?: string;
        region?: string;
        timezone?: string;
        [k: string]: unknown;
    }
}
/**
 * Search the Internet for sources related to the prompt.
 *
 * Learn more about the
 * [web search tool](https://platform.openai.com/docs/guides/tools-web-search).
 */
export interface WebSearchTool {
    type: 'web_search' | 'web_search_2025_08_26';
    /**
     * Filters for the search.
     */
    filters?: WebSearchTool.Filters;
    search_context_size?: 'low' | 'medium' | 'high';
    /**
     * The approximate location of the user.
     */
    user_location?: WebSearchTool.UserLocation;
    [k: string]: unknown;
}
export declare namespace WebSearchTool {
    /**
     * Filters for the search.
     */
    interface Filters {
        allowed_domains?: Array<string>;
        [k: string]: unknown;
    }
    /**
     * The approximate location of the user.
     */
    interface UserLocation {
        city?: string;
        country?: string;
        region?: string;
        timezone?: string;
        type?: 'approximate';
        [k: string]: unknown;
    }
}
/**
 * Emitted when there is a partial audio response.
 */
export type ResponseCreateResponse = OpenAIResponse | ResponseCreateResponse.ResponseAudioDeltaEvent | ResponseCreateResponse.ResponseAudioDoneEvent | ResponseCreateResponse.ResponseAudioTranscriptDeltaEvent | ResponseCreateResponse.ResponseAudioTranscriptDoneEvent | ResponseCreateResponse.ResponseCodeInterpreterCallCodeDeltaEvent | ResponseCreateResponse.ResponseCodeInterpreterCallCodeDoneEvent | ResponseCreateResponse.ResponseCodeInterpreterCallCompletedEvent | ResponseCreateResponse.ResponseCodeInterpreterCallInProgressEvent | ResponseCreateResponse.ResponseCodeInterpreterCallInterpretingEvent | ResponseCreateResponse.ResponseCompletedEvent | ResponseCreateResponse.ResponseContentPartAddedEvent | ResponseCreateResponse.ResponseContentPartDoneEvent | ResponseCreateResponse.ResponseCreatedEvent | ResponseCreateResponse.ResponseErrorEvent | ResponseCreateResponse.ResponseFileSearchCallCompletedEvent | ResponseCreateResponse.ResponseFileSearchCallInProgressEvent | ResponseCreateResponse.ResponseFileSearchCallSearchingEvent | ResponseCreateResponse.ResponseFunctionCallArgumentsDeltaEvent | ResponseCreateResponse.ResponseFunctionCallArgumentsDoneEvent | ResponseCreateResponse.ResponseInProgressEvent | ResponseCreateResponse.ResponseFailedEvent | ResponseCreateResponse.ResponseIncompleteEvent | ResponseCreateResponse.ResponseOutputItemAddedEvent | ResponseCreateResponse.ResponseOutputItemDoneEvent | ResponseCreateResponse.ResponseReasoningSummaryPartAddedEvent | ResponseCreateResponse.ResponseReasoningSummaryPartDoneEvent | ResponseCreateResponse.ResponseReasoningSummaryTextDeltaEvent | ResponseCreateResponse.ResponseReasoningSummaryTextDoneEvent | ResponseCreateResponse.ResponseReasoningTextDeltaEvent | ResponseCreateResponse.ResponseReasoningTextDoneEvent | ResponseCreateResponse.ResponseRefusalDeltaEvent | ResponseCreateResponse.ResponseRefusalDoneEvent | ResponseCreateResponse.ResponseTextDeltaEvent | ResponseCreateResponse.ResponseTextDoneEvent | ResponseCreateResponse.ResponseWebSearchCallCompletedEvent | ResponseCreateResponse.ResponseWebSearchCallInProgressEvent | ResponseCreateResponse.ResponseWebSearchCallSearchingEvent | ResponseCreateResponse.ResponseImageGenCallCompletedEvent | ResponseCreateResponse.ResponseImageGenCallGeneratingEvent | ResponseCreateResponse.ResponseImageGenCallInProgressEvent | ResponseCreateResponse.ResponseImageGenCallPartialImageEvent | ResponseCreateResponse.ResponseMcpCallArgumentsDeltaEvent | ResponseCreateResponse.ResponseMcpCallArgumentsDoneEvent | ResponseCreateResponse.ResponseMcpCallCompletedEvent | ResponseCreateResponse.ResponseMcpCallFailedEvent | ResponseCreateResponse.ResponseMcpCallInProgressEvent | ResponseCreateResponse.ResponseMcpListToolsCompletedEvent | ResponseCreateResponse.ResponseMcpListToolsFailedEvent | ResponseCreateResponse.ResponseMcpListToolsInProgressEvent | ResponseCreateResponse.ResponseOutputTextAnnotationAddedEvent | ResponseCreateResponse.ResponseQueuedEvent | ResponseCreateResponse.ResponseCustomToolCallInputDeltaEvent | ResponseCreateResponse.ResponseCustomToolCallInputDoneEvent | ResponseCreateResponse.GenericResponseEvent;
export declare namespace ResponseCreateResponse {
    /**
     * Emitted when there is a partial audio response.
     */
    interface ResponseAudioDeltaEvent {
        delta: string;
        sequence_number: number;
        type: 'response.audio.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when the audio response is complete.
     */
    interface ResponseAudioDoneEvent {
        sequence_number: number;
        type: 'response.audio.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when there is a partial transcript of audio.
     */
    interface ResponseAudioTranscriptDeltaEvent {
        delta: string;
        sequence_number: number;
        type: 'response.audio.transcript.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when the full audio transcript is completed.
     */
    interface ResponseAudioTranscriptDoneEvent {
        sequence_number: number;
        type: 'response.audio.transcript.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when a partial code snippet is streamed by the code interpreter.
     */
    interface ResponseCodeInterpreterCallCodeDeltaEvent {
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.code_interpreter_call_code.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when the code snippet is finalized by the code interpreter.
     */
    interface ResponseCodeInterpreterCallCodeDoneEvent {
        code: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.code_interpreter_call_code.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when the code interpreter call is completed.
     */
    interface ResponseCodeInterpreterCallCompletedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.code_interpreter_call.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when a code interpreter call is in progress.
     */
    interface ResponseCodeInterpreterCallInProgressEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.code_interpreter_call.in_progress';
        [k: string]: unknown;
    }
    /**
     * Emitted when the code interpreter is actively interpreting the code snippet.
     */
    interface ResponseCodeInterpreterCallInterpretingEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.code_interpreter_call.interpreting';
        [k: string]: unknown;
    }
    /**
     * Emitted when the model response is complete.
     */
    interface ResponseCompletedEvent {
        response: ResponsesAPI.OpenAIResponse;
        sequence_number: number;
        type: 'response.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when a new content part is added.
     */
    interface ResponseContentPartAddedEvent {
        content_index: number;
        item_id: string;
        output_index: number;
        /**
         * A text output from the model.
         */
        part: ResponsesAPI.OpenAIResponseOutputText | ResponsesAPI.OpenAIResponseOutputRefusal | ResponsesAPI.PartReasoningText;
        sequence_number: number;
        type: 'response.content_part.added';
        [k: string]: unknown;
    }
    /**
     * Emitted when a content part is done.
     */
    interface ResponseContentPartDoneEvent {
        content_index: number;
        item_id: string;
        output_index: number;
        /**
         * A text output from the model.
         */
        part: ResponsesAPI.OpenAIResponseOutputText | ResponsesAPI.OpenAIResponseOutputRefusal | ResponsesAPI.PartReasoningText;
        sequence_number: number;
        type: 'response.content_part.done';
        [k: string]: unknown;
    }
    /**
     * An event that is emitted when a response is created.
     */
    interface ResponseCreatedEvent {
        response: ResponsesAPI.OpenAIResponse;
        sequence_number: number;
        type: 'response.created';
        [k: string]: unknown;
    }
    /**
     * Emitted when an error occurs.
     */
    interface ResponseErrorEvent {
        message: string;
        sequence_number: number;
        type: 'error';
        code?: string;
        param?: string;
        [k: string]: unknown;
    }
    /**
     * Emitted when a file search call is completed (results found).
     */
    interface ResponseFileSearchCallCompletedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.file_search_call.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when a file search call is initiated.
     */
    interface ResponseFileSearchCallInProgressEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.file_search_call.in_progress';
        [k: string]: unknown;
    }
    /**
     * Emitted when a file search is currently searching.
     */
    interface ResponseFileSearchCallSearchingEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.file_search_call.searching';
        [k: string]: unknown;
    }
    /**
     * Emitted when there is a partial function-call arguments delta.
     */
    interface ResponseFunctionCallArgumentsDeltaEvent {
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.function_call_arguments.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when function-call arguments are finalized.
     */
    interface ResponseFunctionCallArgumentsDoneEvent {
        arguments: string;
        item_id: string;
        name: string;
        output_index: number;
        sequence_number: number;
        type: 'response.function_call_arguments.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when the response is in progress.
     */
    interface ResponseInProgressEvent {
        response: ResponsesAPI.OpenAIResponse;
        sequence_number: number;
        type: 'response.in_progress';
        [k: string]: unknown;
    }
    /**
     * An event that is emitted when a response fails.
     */
    interface ResponseFailedEvent {
        response: ResponsesAPI.OpenAIResponse;
        sequence_number: number;
        type: 'response.failed';
        [k: string]: unknown;
    }
    /**
     * An event that is emitted when a response finishes as incomplete.
     */
    interface ResponseIncompleteEvent {
        response: ResponsesAPI.OpenAIResponse;
        sequence_number: number;
        type: 'response.incomplete';
        [k: string]: unknown;
    }
    /**
     * Emitted when a new output item is added.
     */
    interface ResponseOutputItemAddedEvent {
        /**
         * An output message from the model.
         */
        item: ResponsesAPI.OpenAIResponseOutputMessage | ResponsesAPI.OpenAIResponseFileSearchToolCall | ResponsesAPI.OpenAIResponseFunctionToolCall | ResponsesAPI.OpenAIResponseFunctionWebSearch | ResponsesAPI.OpenAIResponseComputerToolCall | ResponsesAPI.OpenAIResponseReasoningItem | ResponsesAPI.ResponseCompactionItem | ResponsesAPI.OpenAITypesResponsesResponseOutputItemImageGenerationCall | ResponsesAPI.OpenAIResponseCodeInterpreterToolCall | ResponsesAPI.OpenAITypesResponsesResponseOutputItemLocalShellCall | ResponsesAPI.ResponseFunctionShellToolCall | ResponsesAPI.ResponseFunctionShellToolCallOutput | ResponsesAPI.ResponseApplyPatchToolCall | ResponsesAPI.ResponseApplyPatchToolCallOutput | ResponsesAPI.OpenAITypesResponsesResponseOutputItemMcpCall | ResponsesAPI.OpenAITypesResponsesResponseOutputItemMcpListTools | ResponsesAPI.McpApprovalRequest | ResponsesAPI.OpenAIResponseCustomToolCall;
        output_index: number;
        sequence_number: number;
        type: 'response.output_item.added';
        [k: string]: unknown;
    }
    /**
     * Emitted when an output item is marked done.
     */
    interface ResponseOutputItemDoneEvent {
        /**
         * An output message from the model.
         */
        item: ResponsesAPI.OpenAIResponseOutputMessage | ResponsesAPI.OpenAIResponseFileSearchToolCall | ResponsesAPI.OpenAIResponseFunctionToolCall | ResponsesAPI.OpenAIResponseFunctionWebSearch | ResponsesAPI.OpenAIResponseComputerToolCall | ResponsesAPI.OpenAIResponseReasoningItem | ResponsesAPI.ResponseCompactionItem | ResponsesAPI.OpenAITypesResponsesResponseOutputItemImageGenerationCall | ResponsesAPI.OpenAIResponseCodeInterpreterToolCall | ResponsesAPI.OpenAITypesResponsesResponseOutputItemLocalShellCall | ResponsesAPI.ResponseFunctionShellToolCall | ResponsesAPI.ResponseFunctionShellToolCallOutput | ResponsesAPI.ResponseApplyPatchToolCall | ResponsesAPI.ResponseApplyPatchToolCallOutput | ResponsesAPI.OpenAITypesResponsesResponseOutputItemMcpCall | ResponsesAPI.OpenAITypesResponsesResponseOutputItemMcpListTools | ResponsesAPI.McpApprovalRequest | ResponsesAPI.OpenAIResponseCustomToolCall;
        output_index: number;
        sequence_number: number;
        type: 'response.output_item.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when a new reasoning summary part is added.
     */
    interface ResponseReasoningSummaryPartAddedEvent {
        item_id: string;
        output_index: number;
        /**
         * The summary part that was added.
         */
        part: ResponseReasoningSummaryPartAddedEvent.Part;
        sequence_number: number;
        summary_index: number;
        type: 'response.reasoning_summary_part.added';
        [k: string]: unknown;
    }
    namespace ResponseReasoningSummaryPartAddedEvent {
        /**
         * The summary part that was added.
         */
        interface Part {
            text: string;
            type: 'summary_text';
            [k: string]: unknown;
        }
    }
    /**
     * Emitted when a reasoning summary part is completed.
     */
    interface ResponseReasoningSummaryPartDoneEvent {
        item_id: string;
        output_index: number;
        /**
         * The completed summary part.
         */
        part: ResponseReasoningSummaryPartDoneEvent.Part;
        sequence_number: number;
        summary_index: number;
        type: 'response.reasoning_summary_part.done';
        [k: string]: unknown;
    }
    namespace ResponseReasoningSummaryPartDoneEvent {
        /**
         * The completed summary part.
         */
        interface Part {
            text: string;
            type: 'summary_text';
            [k: string]: unknown;
        }
    }
    /**
     * Emitted when a delta is added to a reasoning summary text.
     */
    interface ResponseReasoningSummaryTextDeltaEvent {
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        summary_index: number;
        type: 'response.reasoning_summary_text.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when a reasoning summary text is completed.
     */
    interface ResponseReasoningSummaryTextDoneEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        summary_index: number;
        text: string;
        type: 'response.reasoning_summary_text.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when a delta is added to a reasoning text.
     */
    interface ResponseReasoningTextDeltaEvent {
        content_index: number;
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.reasoning_text.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when a reasoning text is completed.
     */
    interface ResponseReasoningTextDoneEvent {
        content_index: number;
        item_id: string;
        output_index: number;
        sequence_number: number;
        text: string;
        type: 'response.reasoning_text.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when there is a partial refusal text.
     */
    interface ResponseRefusalDeltaEvent {
        content_index: number;
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.refusal.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when refusal text is finalized.
     */
    interface ResponseRefusalDoneEvent {
        content_index: number;
        item_id: string;
        output_index: number;
        refusal: string;
        sequence_number: number;
        type: 'response.refusal.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when there is an additional text delta.
     */
    interface ResponseTextDeltaEvent {
        content_index: number;
        delta: string;
        item_id: string;
        logprobs: Array<ResponseTextDeltaEvent.Logprob>;
        output_index: number;
        sequence_number: number;
        type: 'response.output_text.delta';
        [k: string]: unknown;
    }
    namespace ResponseTextDeltaEvent {
        /**
         * A logprob is the logarithmic probability that the model assigns to producing a
         * particular token at a given position in the sequence. Less-negative (higher)
         * logprob values indicate greater model confidence in that token choice.
         */
        interface Logprob {
            token: string;
            logprob: number;
            top_logprobs?: Array<Logprob.TopLogprob>;
            [k: string]: unknown;
        }
        namespace Logprob {
            interface TopLogprob {
                token?: string;
                logprob?: number;
                [k: string]: unknown;
            }
        }
    }
    /**
     * Emitted when text content is finalized.
     */
    interface ResponseTextDoneEvent {
        content_index: number;
        item_id: string;
        logprobs: Array<ResponseTextDoneEvent.Logprob>;
        output_index: number;
        sequence_number: number;
        text: string;
        type: 'response.output_text.done';
        [k: string]: unknown;
    }
    namespace ResponseTextDoneEvent {
        /**
         * A logprob is the logarithmic probability that the model assigns to producing a
         * particular token at a given position in the sequence. Less-negative (higher)
         * logprob values indicate greater model confidence in that token choice.
         */
        interface Logprob {
            token: string;
            logprob: number;
            top_logprobs?: Array<Logprob.TopLogprob>;
            [k: string]: unknown;
        }
        namespace Logprob {
            interface TopLogprob {
                token?: string;
                logprob?: number;
                [k: string]: unknown;
            }
        }
    }
    /**
     * Emitted when a web search call is completed.
     */
    interface ResponseWebSearchCallCompletedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.web_search_call.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when a web search call is initiated.
     */
    interface ResponseWebSearchCallInProgressEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.web_search_call.in_progress';
        [k: string]: unknown;
    }
    /**
     * Emitted when a web search call is executing.
     */
    interface ResponseWebSearchCallSearchingEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.web_search_call.searching';
        [k: string]: unknown;
    }
    /**
     * Emitted when an image generation tool call has completed and the final image is
     * available.
     */
    interface ResponseImageGenCallCompletedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.image_generation_call.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when an image generation tool call is actively generating an image
     * (intermediate state).
     */
    interface ResponseImageGenCallGeneratingEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.image_generation_call.generating';
        [k: string]: unknown;
    }
    /**
     * Emitted when an image generation tool call is in progress.
     */
    interface ResponseImageGenCallInProgressEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.image_generation_call.in_progress';
        [k: string]: unknown;
    }
    /**
     * Emitted when a partial image is available during image generation streaming.
     */
    interface ResponseImageGenCallPartialImageEvent {
        item_id: string;
        output_index: number;
        partial_image_b64: string;
        partial_image_index: number;
        sequence_number: number;
        type: 'response.image_generation_call.partial_image';
        [k: string]: unknown;
    }
    /**
     * Emitted when there is a delta (partial update) to the arguments of an MCP tool
     * call.
     */
    interface ResponseMcpCallArgumentsDeltaEvent {
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_call_arguments.delta';
        [k: string]: unknown;
    }
    /**
     * Emitted when the arguments for an MCP tool call are finalized.
     */
    interface ResponseMcpCallArgumentsDoneEvent {
        arguments: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_call_arguments.done';
        [k: string]: unknown;
    }
    /**
     * Emitted when an MCP tool call has completed successfully.
     */
    interface ResponseMcpCallCompletedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_call.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when an MCP tool call has failed.
     */
    interface ResponseMcpCallFailedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_call.failed';
        [k: string]: unknown;
    }
    /**
     * Emitted when an MCP tool call is in progress.
     */
    interface ResponseMcpCallInProgressEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_call.in_progress';
        [k: string]: unknown;
    }
    /**
     * Emitted when the list of available MCP tools has been successfully retrieved.
     */
    interface ResponseMcpListToolsCompletedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_list_tools.completed';
        [k: string]: unknown;
    }
    /**
     * Emitted when the attempt to list available MCP tools has failed.
     */
    interface ResponseMcpListToolsFailedEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_list_tools.failed';
        [k: string]: unknown;
    }
    /**
     * Emitted when the system is in the process of retrieving the list of available
     * MCP tools.
     */
    interface ResponseMcpListToolsInProgressEvent {
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.mcp_list_tools.in_progress';
        [k: string]: unknown;
    }
    /**
     * Emitted when an annotation is added to output text content.
     */
    interface ResponseOutputTextAnnotationAddedEvent {
        annotation: unknown;
        annotation_index: number;
        content_index: number;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.output_text.annotation.added';
        [k: string]: unknown;
    }
    /**
     * Emitted when a response is queued and waiting to be processed.
     */
    interface ResponseQueuedEvent {
        response: ResponsesAPI.OpenAIResponse;
        sequence_number: number;
        type: 'response.queued';
        [k: string]: unknown;
    }
    /**
     * Event representing a delta (partial update) to the input of a custom tool call.
     */
    interface ResponseCustomToolCallInputDeltaEvent {
        delta: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.custom_tool_call_input.delta';
        [k: string]: unknown;
    }
    /**
     * Event indicating that input for a custom tool call is complete.
     */
    interface ResponseCustomToolCallInputDoneEvent {
        input: string;
        item_id: string;
        output_index: number;
        sequence_number: number;
        type: 'response.custom_tool_call_input.done';
        [k: string]: unknown;
    }
    interface GenericResponseEvent {
        type: string;
        [k: string]: unknown;
    }
}
export interface ResponseCreateParams {
    input: string | Array<ResponseCreateParams.EasyInputMessageParam | ResponseCreateParams.OpenAITypesResponsesResponseInputParamMessage | ResponseCreateParams.ResponseOutputMessageParam | ResponseCreateParams.ResponseFileSearchToolCallParam | ResponseCreateParams.ResponseComputerToolCallParam | ResponseCreateParams.OpenAITypesResponsesResponseInputParamComputerCallOutput | ResponseCreateParams.ResponseFunctionWebSearchParam | ResponseCreateParams.ResponseFunctionToolCallParam | ResponseCreateParams.OpenAITypesResponsesResponseInputParamFunctionCallOutput | ResponseCreateParams.ResponseReasoningItemParam | ResponseCreateParams.ResponseCompactionItemParamParam | ResponseCreateParams.OpenAITypesResponsesResponseInputParamImageGenerationCall | ResponseCreateParams.ResponseCodeInterpreterToolCallParam | ResponseCreateParams.OpenAITypesResponsesResponseInputParamLocalShellCall | ResponseCreateParams.OpenAITypesResponsesResponseInputParamLocalShellCallOutput | ResponseCreateParams.OpenAITypesResponsesResponseInputParamShellCall | ResponseCreateParams.OpenAITypesResponsesResponseInputParamShellCallOutput | ResponseCreateParams.OpenAITypesResponsesResponseInputParamApplyPatchCall | ResponseCreateParams.OpenAITypesResponsesResponseInputParamApplyPatchCallOutput | ResponseCreateParams.OpenAITypesResponsesResponseInputParamMcpListTools | McpApprovalRequest | ResponseCreateParams.OpenAITypesResponsesResponseInputParamMcpApprovalResponse | ResponseCreateParams.OpenAITypesResponsesResponseInputParamMcpCall | ResponseCreateParams.ResponseCustomToolCallOutputParam | ResponseCreateParams.ResponseCustomToolCallParam | ResponseCreateParams.OpenAITypesResponsesResponseInputParamItemReference>;
    /**
     * model specified as `model_vendor/model`, for example `openai/gpt-4o`
     */
    model: string;
    /**
     * Which fields to include in the response
     */
    include?: Array<string>;
    /**
     * Instructions for the response generation
     */
    instructions?: string;
    /**
     * Maximum number of output tokens
     */
    max_output_tokens?: number;
    /**
     * Metadata for the response
     */
    metadata?: {
        [key: string]: unknown;
    };
    /**
     * Whether to enable parallel tool calls
     */
    parallel_tool_calls?: boolean;
    /**
     * ID of the previous response for chaining
     */
    previous_response_id?: string;
    /**
     * Reasoning configuration for the response
     */
    reasoning?: {
        [key: string]: unknown;
    };
    /**
     * Whether to store the response
     */
    store?: boolean;
    /**
     * Whether to stream the response
     */
    stream?: boolean;
    /**
     * Sampling temperature for randomness control
     */
    temperature?: number;
    /**
     * Text configuration parameters
     */
    text?: {
        [key: string]: unknown;
    };
    /**
     * Tool choice configuration
     */
    tool_choice?: string | {
        [key: string]: unknown;
    };
    /**
     * Tools available for the response
     */
    tools?: Array<{
        [key: string]: unknown;
    }>;
    /**
     * Top-p sampling parameter
     */
    top_p?: number;
    /**
     * Truncation configuration
     */
    truncation?: 'auto' | 'disabled';
    [k: string]: unknown;
}
export declare namespace ResponseCreateParams {
    /**
     * A message input to the model with a role indicating instruction following
     * hierarchy. Instructions given with the `developer` or `system` role take
     * precedence over instructions given with the `user` role. Messages with the
     * `assistant` role are presumed to have been generated by the model in previous
     * interactions.
     */
    interface EasyInputMessageParam {
        content: string | Array<ResponsesAPI.OpenAIResponseInputTextParam | ResponsesAPI.OpenAIResponseInputImageParam | ResponsesAPI.OpenAIResponseInputFileParam>;
        role: 'user' | 'assistant' | 'system' | 'developer';
        phase?: 'commentary' | 'final_answer';
        type?: 'message';
        [k: string]: unknown;
    }
    /**
     * A message input to the model with a role indicating instruction following
     * hierarchy. Instructions given with the `developer` or `system` role take
     * precedence over instructions given with the `user` role.
     */
    interface OpenAITypesResponsesResponseInputParamMessage {
        content: Array<ResponsesAPI.OpenAIResponseInputTextParam | ResponsesAPI.OpenAIResponseInputImageParam | ResponsesAPI.OpenAIResponseInputFileParam>;
        role: 'user' | 'system' | 'developer';
        status?: 'in_progress' | 'completed' | 'incomplete';
        type?: 'message';
        [k: string]: unknown;
    }
    /**
     * An output message from the model.
     */
    interface ResponseOutputMessageParam {
        id: string;
        content: Array<ResponseOutputMessageParam.ResponseOutputTextParam | ResponseOutputMessageParam.ResponseOutputRefusalParam>;
        role: 'assistant';
        status: 'in_progress' | 'completed' | 'incomplete';
        type: 'message';
        phase?: 'commentary' | 'final_answer';
        [k: string]: unknown;
    }
    namespace ResponseOutputMessageParam {
        /**
         * A text output from the model.
         */
        interface ResponseOutputTextParam {
            annotations: Array<ResponseOutputTextParam.AnnotationFileCitation | ResponseOutputTextParam.OpenAITypesResponsesResponseOutputTextParamAnnotationURLCitation | ResponseOutputTextParam.AnnotationContainerFileCitation | ResponseOutputTextParam.AnnotationFilePath>;
            text: string;
            type: 'output_text';
            logprobs?: Array<ResponseOutputTextParam.Logprob>;
            [k: string]: unknown;
        }
        namespace ResponseOutputTextParam {
            /**
             * A citation to a file.
             */
            interface AnnotationFileCitation {
                file_id: string;
                filename: string;
                index: number;
                type: 'file_citation';
                [k: string]: unknown;
            }
            /**
             * A citation for a web resource used to generate a model response.
             */
            interface OpenAITypesResponsesResponseOutputTextParamAnnotationURLCitation {
                end_index: number;
                start_index: number;
                title: string;
                type: 'url_citation';
                url: string;
                [k: string]: unknown;
            }
            /**
             * A citation for a container file used to generate a model response.
             */
            interface AnnotationContainerFileCitation {
                container_id: string;
                end_index: number;
                file_id: string;
                filename: string;
                start_index: number;
                type: 'container_file_citation';
                [k: string]: unknown;
            }
            /**
             * A path to a file.
             */
            interface AnnotationFilePath {
                file_id: string;
                index: number;
                type: 'file_path';
                [k: string]: unknown;
            }
            /**
             * The log probability of a token.
             */
            interface Logprob {
                token: string;
                bytes: Array<number>;
                logprob: number;
                top_logprobs: Array<Logprob.TopLogprob>;
                [k: string]: unknown;
            }
            namespace Logprob {
                /**
                 * The top log probability of a token.
                 */
                interface TopLogprob {
                    token: string;
                    bytes: Array<number>;
                    logprob: number;
                    [k: string]: unknown;
                }
            }
        }
        /**
         * A refusal from the model.
         */
        interface ResponseOutputRefusalParam {
            refusal: string;
            type: 'refusal';
            [k: string]: unknown;
        }
    }
    /**
     * The results of a file search tool call.
     *
     * See the
     * [file search guide](https://platform.openai.com/docs/guides/tools-file-search)
     * for more information.
     */
    interface ResponseFileSearchToolCallParam {
        id: string;
        queries: Array<string>;
        status: 'in_progress' | 'searching' | 'completed' | 'incomplete' | 'failed';
        type: 'file_search_call';
        results?: Array<ResponseFileSearchToolCallParam.Result>;
        [k: string]: unknown;
    }
    namespace ResponseFileSearchToolCallParam {
        interface Result {
            attributes?: {
                [key: string]: string | number | boolean;
            };
            file_id?: string;
            filename?: string;
            score?: number;
            text?: string;
            [k: string]: unknown;
        }
    }
    /**
     * A tool call to a computer use tool.
     *
     * See the
     * [computer use guide](https://platform.openai.com/docs/guides/tools-computer-use)
     * for more information.
     */
    interface ResponseComputerToolCallParam {
        id: string;
        /**
         * A click action.
         */
        action: ResponseComputerToolCallParam.ActionClick | ResponseComputerToolCallParam.ActionDoubleClick | ResponseComputerToolCallParam.ActionDrag | ResponseComputerToolCallParam.ActionKeypress | ResponseComputerToolCallParam.ActionMove | ResponseComputerToolCallParam.ActionScreenshot | ResponseComputerToolCallParam.ActionScroll | ResponseComputerToolCallParam.ActionType | ResponseComputerToolCallParam.ActionWait;
        call_id: string;
        pending_safety_checks: Array<ResponseComputerToolCallParam.PendingSafetyCheck>;
        status: 'in_progress' | 'completed' | 'incomplete';
        type: 'computer_call';
        [k: string]: unknown;
    }
    namespace ResponseComputerToolCallParam {
        /**
         * A click action.
         */
        interface ActionClick {
            button: 'left' | 'right' | 'wheel' | 'back' | 'forward';
            type: 'click';
            x: number;
            y: number;
            [k: string]: unknown;
        }
        /**
         * A double click action.
         */
        interface ActionDoubleClick {
            type: 'double_click';
            x: number;
            y: number;
            [k: string]: unknown;
        }
        /**
         * A drag action.
         */
        interface ActionDrag {
            path: Array<ActionDrag.Path>;
            type: 'drag';
            [k: string]: unknown;
        }
        namespace ActionDrag {
            /**
             * An x/y coordinate pair, e.g. `{ x: 100, y: 200 }`.
             */
            interface Path {
                x: number;
                y: number;
                [k: string]: unknown;
            }
        }
        /**
         * A collection of keypresses the model would like to perform.
         */
        interface ActionKeypress {
            keys: Array<string>;
            type: 'keypress';
            [k: string]: unknown;
        }
        /**
         * A mouse move action.
         */
        interface ActionMove {
            type: 'move';
            x: number;
            y: number;
            [k: string]: unknown;
        }
        /**
         * A screenshot action.
         */
        interface ActionScreenshot {
            type: 'screenshot';
            [k: string]: unknown;
        }
        /**
         * A scroll action.
         */
        interface ActionScroll {
            scroll_x: number;
            scroll_y: number;
            type: 'scroll';
            x: number;
            y: number;
            [k: string]: unknown;
        }
        /**
         * An action to type in text.
         */
        interface ActionType {
            text: string;
            type: 'type';
            [k: string]: unknown;
        }
        /**
         * A wait action.
         */
        interface ActionWait {
            type: 'wait';
            [k: string]: unknown;
        }
        /**
         * A pending safety check for the computer call.
         */
        interface PendingSafetyCheck {
            id: string;
            code?: string;
            message?: string;
            [k: string]: unknown;
        }
    }
    /**
     * The output of a computer tool call.
     */
    interface OpenAITypesResponsesResponseInputParamComputerCallOutput {
        call_id: string;
        /**
         * A computer screenshot image used with the computer use tool.
         */
        output: OpenAITypesResponsesResponseInputParamComputerCallOutput.Output;
        type: 'computer_call_output';
        id?: string;
        acknowledged_safety_checks?: Array<OpenAITypesResponsesResponseInputParamComputerCallOutput.AcknowledgedSafetyCheck>;
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamComputerCallOutput {
        /**
         * A computer screenshot image used with the computer use tool.
         */
        interface Output {
            type: 'computer_screenshot';
            file_id?: string;
            image_url?: string;
            [k: string]: unknown;
        }
        /**
         * A pending safety check for the computer call.
         */
        interface AcknowledgedSafetyCheck {
            id: string;
            code?: string;
            message?: string;
            [k: string]: unknown;
        }
    }
    /**
     * The results of a web search tool call.
     *
     * See the
     * [web search guide](https://platform.openai.com/docs/guides/tools-web-search) for
     * more information.
     */
    interface ResponseFunctionWebSearchParam {
        id: string;
        /**
         * Action type "search" - Performs a web search query.
         */
        action: ResponseFunctionWebSearchParam.OpenAITypesResponsesResponseFunctionWebSearchParamActionSearch | ResponseFunctionWebSearchParam.OpenAITypesResponsesResponseFunctionWebSearchParamActionOpenPage | ResponseFunctionWebSearchParam.ActionFind;
        status: 'in_progress' | 'searching' | 'completed' | 'failed';
        type: 'web_search_call';
        [k: string]: unknown;
    }
    namespace ResponseFunctionWebSearchParam {
        /**
         * Action type "search" - Performs a web search query.
         */
        interface OpenAITypesResponsesResponseFunctionWebSearchParamActionSearch {
            query: string;
            type: 'search';
            queries?: Array<string>;
            sources?: Array<OpenAITypesResponsesResponseFunctionWebSearchParamActionSearch.Source>;
            [k: string]: unknown;
        }
        namespace OpenAITypesResponsesResponseFunctionWebSearchParamActionSearch {
            /**
             * A source used in the search.
             */
            interface Source {
                type: 'url';
                url: string;
                [k: string]: unknown;
            }
        }
        /**
         * Action type "open_page" - Opens a specific URL from search results.
         */
        interface OpenAITypesResponsesResponseFunctionWebSearchParamActionOpenPage {
            type: 'open_page';
            url?: string;
            [k: string]: unknown;
        }
        /**
         * Action type "find_in_page": Searches for a pattern within a loaded page.
         */
        interface ActionFind {
            pattern: string;
            type: 'find_in_page';
            url: string;
            [k: string]: unknown;
        }
    }
    /**
     * A tool call to run a function.
     *
     * See the
     * [function calling guide](https://platform.openai.com/docs/guides/function-calling)
     * for more information.
     */
    interface ResponseFunctionToolCallParam {
        arguments: string;
        call_id: string;
        name: string;
        type: 'function_call';
        id?: string;
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    /**
     * The output of a function tool call.
     */
    interface OpenAITypesResponsesResponseInputParamFunctionCallOutput {
        call_id: string;
        output: string | Array<OpenAITypesResponsesResponseInputParamFunctionCallOutput.ResponseInputTextContentParam | OpenAITypesResponsesResponseInputParamFunctionCallOutput.ResponseInputImageContentParam | OpenAITypesResponsesResponseInputParamFunctionCallOutput.ResponseInputFileContentParam>;
        type: 'function_call_output';
        id?: string;
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamFunctionCallOutput {
        /**
         * A text input to the model.
         */
        interface ResponseInputTextContentParam {
            text: string;
            type: 'input_text';
            [k: string]: unknown;
        }
        /**
         * An image input to the model.
         *
         * Learn about [image inputs](https://platform.openai.com/docs/guides/vision)
         */
        interface ResponseInputImageContentParam {
            type: 'input_image';
            detail?: 'low' | 'high' | 'auto';
            file_id?: string;
            image_url?: string;
            [k: string]: unknown;
        }
        /**
         * A file input to the model.
         */
        interface ResponseInputFileContentParam {
            type: 'input_file';
            file_data?: string;
            file_id?: string;
            file_url?: string;
            filename?: string;
            [k: string]: unknown;
        }
    }
    /**
     * A description of the chain of thought used by a reasoning model while generating
     * a response. Be sure to include these items in your `input` to the Responses API
     * for subsequent turns of a conversation if you are manually
     * [managing context](https://platform.openai.com/docs/guides/conversation-state).
     */
    interface ResponseReasoningItemParam {
        id: string;
        summary: Array<ResponseReasoningItemParam.Summary>;
        type: 'reasoning';
        content?: Array<ResponseReasoningItemParam.Content>;
        encrypted_content?: string;
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    namespace ResponseReasoningItemParam {
        /**
         * A summary text from the model.
         */
        interface Summary {
            text: string;
            type: 'summary_text';
            [k: string]: unknown;
        }
        /**
         * Reasoning text from the model.
         */
        interface Content {
            text: string;
            type: 'reasoning_text';
            [k: string]: unknown;
        }
    }
    /**
     * A compaction item generated by the
     * [`v1/responses/compact` API](https://platform.openai.com/docs/api-reference/responses/compact).
     */
    interface ResponseCompactionItemParamParam {
        encrypted_content: string;
        type: 'compaction';
        id?: string;
        [k: string]: unknown;
    }
    /**
     * An image generation request made by the model.
     */
    interface OpenAITypesResponsesResponseInputParamImageGenerationCall {
        id: string;
        result: string | null;
        status: 'in_progress' | 'completed' | 'generating' | 'failed';
        type: 'image_generation_call';
        [k: string]: unknown;
    }
    /**
     * A tool call to run code.
     */
    interface ResponseCodeInterpreterToolCallParam {
        id: string;
        code: string | null;
        container_id: string;
        outputs: Array<ResponseCodeInterpreterToolCallParam.OutputLogs | ResponseCodeInterpreterToolCallParam.OutputImage> | null;
        status: 'in_progress' | 'completed' | 'incomplete' | 'interpreting' | 'failed';
        type: 'code_interpreter_call';
        [k: string]: unknown;
    }
    namespace ResponseCodeInterpreterToolCallParam {
        /**
         * The logs output from the code interpreter.
         */
        interface OutputLogs {
            logs: string;
            type: 'logs';
            [k: string]: unknown;
        }
        /**
         * The image output from the code interpreter.
         */
        interface OutputImage {
            type: 'image';
            url: string;
            [k: string]: unknown;
        }
    }
    /**
     * A tool call to run a command on the local shell.
     */
    interface OpenAITypesResponsesResponseInputParamLocalShellCall {
        id: string;
        /**
         * Execute a shell command on the server.
         */
        action: OpenAITypesResponsesResponseInputParamLocalShellCall.Action;
        call_id: string;
        status: 'in_progress' | 'completed' | 'incomplete';
        type: 'local_shell_call';
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamLocalShellCall {
        /**
         * Execute a shell command on the server.
         */
        interface Action {
            command: Array<string>;
            env: {
                [key: string]: string;
            };
            type: 'exec';
            timeout_ms?: number;
            user?: string;
            working_directory?: string;
            [k: string]: unknown;
        }
    }
    /**
     * The output of a local shell tool call.
     */
    interface OpenAITypesResponsesResponseInputParamLocalShellCallOutput {
        id: string;
        output: string;
        type: 'local_shell_call_output';
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    /**
     * A tool representing a request to execute one or more shell commands.
     */
    interface OpenAITypesResponsesResponseInputParamShellCall {
        /**
         * The shell commands and limits that describe how to run the tool call.
         */
        action: OpenAITypesResponsesResponseInputParamShellCall.Action;
        call_id: string;
        type: 'shell_call';
        id?: string;
        environment?: ResponsesAPI.LocalEnvironmentParam | ResponsesAPI.ContainerReferenceParam;
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamShellCall {
        /**
         * The shell commands and limits that describe how to run the tool call.
         */
        interface Action {
            commands: Array<string>;
            max_output_length?: number;
            timeout_ms?: number;
            [k: string]: unknown;
        }
    }
    /**
     * The streamed output items emitted by a shell tool call.
     */
    interface OpenAITypesResponsesResponseInputParamShellCallOutput {
        call_id: string;
        output: Array<OpenAITypesResponsesResponseInputParamShellCallOutput.Output>;
        type: 'shell_call_output';
        id?: string;
        max_output_length?: number;
        status?: 'in_progress' | 'completed' | 'incomplete';
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamShellCallOutput {
        /**
         * Captured stdout and stderr for a portion of a shell tool call output.
         */
        interface Output {
            /**
             * Indicates that the shell call exceeded its configured time limit.
             */
            outcome: Output.OutcomeTimeout | Output.OutcomeExit;
            stderr: string;
            stdout: string;
            [k: string]: unknown;
        }
        namespace Output {
            /**
             * Indicates that the shell call exceeded its configured time limit.
             */
            interface OutcomeTimeout {
                type: 'timeout';
                [k: string]: unknown;
            }
            /**
             * Indicates that the shell commands finished and returned an exit code.
             */
            interface OutcomeExit {
                exit_code: number;
                type: 'exit';
                [k: string]: unknown;
            }
        }
    }
    /**
     * A tool call representing a request to create, delete, or update files using diff
     * patches.
     */
    interface OpenAITypesResponsesResponseInputParamApplyPatchCall {
        call_id: string;
        /**
         * Instruction for creating a new file via the apply_patch tool.
         */
        operation: OpenAITypesResponsesResponseInputParamApplyPatchCall.ApplyPatchCallOperationCreateFile | OpenAITypesResponsesResponseInputParamApplyPatchCall.ApplyPatchCallOperationDeleteFile | OpenAITypesResponsesResponseInputParamApplyPatchCall.ApplyPatchCallOperationUpdateFile;
        status: 'in_progress' | 'completed';
        type: 'apply_patch_call';
        id?: string;
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamApplyPatchCall {
        /**
         * Instruction for creating a new file via the apply_patch tool.
         */
        interface ApplyPatchCallOperationCreateFile {
            diff: string;
            path: string;
            type: 'create_file';
            [k: string]: unknown;
        }
        /**
         * Instruction for deleting an existing file via the apply_patch tool.
         */
        interface ApplyPatchCallOperationDeleteFile {
            path: string;
            type: 'delete_file';
            [k: string]: unknown;
        }
        /**
         * Instruction for updating an existing file via the apply_patch tool.
         */
        interface ApplyPatchCallOperationUpdateFile {
            diff: string;
            path: string;
            type: 'update_file';
            [k: string]: unknown;
        }
    }
    /**
     * The streamed output emitted by an apply patch tool call.
     */
    interface OpenAITypesResponsesResponseInputParamApplyPatchCallOutput {
        call_id: string;
        status: 'completed' | 'failed';
        type: 'apply_patch_call_output';
        id?: string;
        output?: string;
        [k: string]: unknown;
    }
    /**
     * A list of tools available on an MCP server.
     */
    interface OpenAITypesResponsesResponseInputParamMcpListTools {
        id: string;
        server_label: string;
        tools: Array<OpenAITypesResponsesResponseInputParamMcpListTools.Tool>;
        type: 'mcp_list_tools';
        error?: string;
        [k: string]: unknown;
    }
    namespace OpenAITypesResponsesResponseInputParamMcpListTools {
        /**
         * A tool available on an MCP server.
         */
        interface Tool {
            input_schema: unknown;
            name: string;
            annotations?: unknown;
            description?: string;
            [k: string]: unknown;
        }
    }
    /**
     * A response to an MCP approval request.
     */
    interface OpenAITypesResponsesResponseInputParamMcpApprovalResponse {
        approval_request_id: string;
        approve: boolean;
        type: 'mcp_approval_response';
        id?: string;
        reason?: string;
        [k: string]: unknown;
    }
    /**
     * An invocation of a tool on an MCP server.
     */
    interface OpenAITypesResponsesResponseInputParamMcpCall {
        id: string;
        arguments: string;
        name: string;
        server_label: string;
        type: 'mcp_call';
        approval_request_id?: string;
        error?: string;
        output?: string;
        status?: 'in_progress' | 'completed' | 'incomplete' | 'calling' | 'failed';
        [k: string]: unknown;
    }
    /**
     * The output of a custom tool call from your code, being sent back to the model.
     */
    interface ResponseCustomToolCallOutputParam {
        call_id: string;
        output: string | Array<ResponsesAPI.OpenAIResponseInputTextParam | ResponsesAPI.OpenAIResponseInputImageParam | ResponsesAPI.OpenAIResponseInputFileParam>;
        type: 'custom_tool_call_output';
        id?: string;
        [k: string]: unknown;
    }
    /**
     * A call to a custom tool created by the model.
     */
    interface ResponseCustomToolCallParam {
        call_id: string;
        input: string;
        name: string;
        type: 'custom_tool_call';
        id?: string;
        [k: string]: unknown;
    }
    /**
     * An internal identifier for an item to reference.
     */
    interface OpenAITypesResponsesResponseInputParamItemReference {
        id: string;
        type?: 'item_reference';
        [k: string]: unknown;
    }
}
export declare namespace Responses {
    export { type ApplyPatchCall as ApplyPatchCall, type ApplyPatchCallOutput as ApplyPatchCallOutput, type ApplyPatchTool as ApplyPatchTool, type ComputerTool as ComputerTool, type ContainerNetworkPolicyAllowlist as ContainerNetworkPolicyAllowlist, type ContainerNetworkPolicyDisabled as ContainerNetworkPolicyDisabled, type ContainerReference as ContainerReference, type ContainerReferenceParam as ContainerReferenceParam, type Conversation as Conversation, type CustomTool as CustomTool, type EasyInputMessage as EasyInputMessage, type FileSearchTool as FileSearchTool, type FunctionShellTool as FunctionShellTool, type FunctionTool as FunctionTool, type IncompleteDetails as IncompleteDetails, type LocalEnvironment as LocalEnvironment, type LocalEnvironmentParam as LocalEnvironmentParam, type McpApprovalRequest as McpApprovalRequest, type OpenAIResponse as OpenAIResponse, type OpenAIResponseCodeInterpreterToolCall as OpenAIResponseCodeInterpreterToolCall, type OpenAIResponseComputerToolCall as OpenAIResponseComputerToolCall, type OpenAIResponseCustomToolCall as OpenAIResponseCustomToolCall, type OpenAIResponseCustomToolCallOutput as OpenAIResponseCustomToolCallOutput, type OpenAIResponseError as OpenAIResponseError, type OpenAIResponseFileSearchToolCall as OpenAIResponseFileSearchToolCall, type OpenAIResponseFunctionToolCall as OpenAIResponseFunctionToolCall, type OpenAIResponseFunctionWebSearch as OpenAIResponseFunctionWebSearch, type OpenAIResponseInputFile as OpenAIResponseInputFile, type OpenAIResponseInputFileParam as OpenAIResponseInputFileParam, type OpenAIResponseInputImage as OpenAIResponseInputImage, type OpenAIResponseInputImageParam as OpenAIResponseInputImageParam, type OpenAIResponseInputText as OpenAIResponseInputText, type OpenAIResponseInputTextParam as OpenAIResponseInputTextParam, type OpenAIResponseOutputMessage as OpenAIResponseOutputMessage, type OpenAIResponseOutputRefusal as OpenAIResponseOutputRefusal, type OpenAIResponseOutputText as OpenAIResponseOutputText, type OpenAIResponsePrompt as OpenAIResponsePrompt, type OpenAIResponseReasoningItem as OpenAIResponseReasoningItem, type OpenAIResponseTextConfig as OpenAIResponseTextConfig, type OpenAIResponseUsage as OpenAIResponseUsage, type OpenAITypesResponsesResponseInputItemComputerCallOutput as OpenAITypesResponsesResponseInputItemComputerCallOutput, type OpenAITypesResponsesResponseInputItemFunctionCallOutput as OpenAITypesResponsesResponseInputItemFunctionCallOutput, type OpenAITypesResponsesResponseInputItemImageGenerationCall as OpenAITypesResponsesResponseInputItemImageGenerationCall, type OpenAITypesResponsesResponseInputItemItemReference as OpenAITypesResponsesResponseInputItemItemReference, type OpenAITypesResponsesResponseInputItemLocalShellCall as OpenAITypesResponsesResponseInputItemLocalShellCall, type OpenAITypesResponsesResponseInputItemLocalShellCallOutput as OpenAITypesResponsesResponseInputItemLocalShellCallOutput, type OpenAITypesResponsesResponseInputItemMcpApprovalResponse as OpenAITypesResponsesResponseInputItemMcpApprovalResponse, type OpenAITypesResponsesResponseInputItemMcpCall as OpenAITypesResponsesResponseInputItemMcpCall, type OpenAITypesResponsesResponseInputItemMcpListTools as OpenAITypesResponsesResponseInputItemMcpListTools, type OpenAITypesResponsesResponseInputItemMessage as OpenAITypesResponsesResponseInputItemMessage, type OpenAITypesResponsesResponseOutputItemImageGenerationCall as OpenAITypesResponsesResponseOutputItemImageGenerationCall, type OpenAITypesResponsesResponseOutputItemLocalShellCall as OpenAITypesResponsesResponseOutputItemLocalShellCall, type OpenAITypesResponsesResponseOutputItemMcpCall as OpenAITypesResponsesResponseOutputItemMcpCall, type OpenAITypesResponsesResponseOutputItemMcpListTools as OpenAITypesResponsesResponseOutputItemMcpListTools, type PartReasoningText as PartReasoningText, type Reasoning as Reasoning, type ResponseApplyPatchToolCall as ResponseApplyPatchToolCall, type ResponseApplyPatchToolCallOutput as ResponseApplyPatchToolCallOutput, type ResponseCompactionItem as ResponseCompactionItem, type ResponseCompactionItemParam as ResponseCompactionItemParam, type ResponseComputerToolCallOutputScreenshot as ResponseComputerToolCallOutputScreenshot, type ResponseFunctionShellToolCall as ResponseFunctionShellToolCall, type ResponseFunctionShellToolCallOutput as ResponseFunctionShellToolCallOutput, type ShellCall as ShellCall, type ShellCallOutput as ShellCallOutput, type ToolChoiceAllowed as ToolChoiceAllowed, type ToolChoiceApplyPatch as ToolChoiceApplyPatch, type ToolChoiceCustom as ToolChoiceCustom, type ToolChoiceFunction as ToolChoiceFunction, type ToolChoiceMcp as ToolChoiceMcp, type ToolChoiceShell as ToolChoiceShell, type ToolChoiceTypes as ToolChoiceTypes, type WebSearchPreviewTool as WebSearchPreviewTool, type WebSearchTool as WebSearchTool, type ResponseCreateResponse as ResponseCreateResponse, type ResponseCreateParams as ResponseCreateParams, };
}
//# sourceMappingURL=responses.d.ts.map