@openrouter/sdk 0.0.0-beta.40 → 0.0.0-beta.42

package/dist/esm/models/openresponsesnonstreamingresponse.js

@@ -5,15 +5,21 @@ import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { catchUnrecognizedEnum, } from "../types/enums.js";
-import { OpenResponsesInput$inboundSchema, OpenResponsesInput$outboundSchema, } from "./openresponsesinput.js";
-import { OpenResponsesPrompt$inboundSchema, OpenResponsesPrompt$outboundSchema, } from "./openresponsesprompt.js";
-import { OpenResponsesReasoningConfig$inboundSchema, OpenResponsesReasoningConfig$outboundSchema, } from "./openresponsesreasoningconfig.js";
-import { OpenResponsesTextConfig$inboundSchema, OpenResponsesTextConfig$outboundSchema, } from "./openresponsestextconfig.js";
-import { OpenResponsesToolChoice$inboundSchema, OpenResponsesToolChoice$outboundSchema, } from "./openresponsestoolchoice.js";
-import { OpenResponsesToolUnion$inboundSchema, OpenResponsesToolUnion$outboundSchema, } from "./openresponsestoolunion.js";
+import { OpenAIResponsesPrompt$inboundSchema, OpenAIResponsesPrompt$outboundSchema, } from "./openairesponsesprompt.js";
+import { OpenResponsesWebSearch20250826Tool$inboundSchema, OpenResponsesWebSearch20250826Tool$outboundSchema, } from "./openresponseswebsearch20250826tool.js";
+import { OpenResponsesWebSearchPreview20250311Tool$inboundSchema, OpenResponsesWebSearchPreview20250311Tool$outboundSchema, } from "./openresponseswebsearchpreview20250311tool.js";
+import { OpenResponsesWebSearchPreviewTool$inboundSchema, OpenResponsesWebSearchPreviewTool$outboundSchema, } from "./openresponseswebsearchpreviewtool.js";
+import { OpenResponsesWebSearchTool$inboundSchema, OpenResponsesWebSearchTool$outboundSchema, } from "./openresponseswebsearchtool.js";
+import { OutputItemImageGenerationCall$inboundSchema, OutputItemImageGenerationCall$outboundSchema, } from "./outputitemimagegenerationcall.js";
+import { OutputMessage$inboundSchema, OutputMessage$outboundSchema, } from "./outputmessage.js";
+import { ReasoningSummaryVerbosity$inboundSchema, ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
+import { ResponseInputFile$inboundSchema, ResponseInputFile$outboundSchema, } from "./responseinputfile.js";
+import { ResponseInputImage$inboundSchema, ResponseInputImage$outboundSchema, } from "./responseinputimage.js";
+import { ResponseInputText$inboundSchema, ResponseInputText$outboundSchema, } from "./responseinputtext.js";
 import { ResponsesErrorField$inboundSchema, ResponsesErrorField$outboundSchema, } from "./responseserrorfield.js";
 import { ResponsesOutputItem$inboundSchema, ResponsesOutputItem$outboundSchema, } from "./responsesoutputitem.js";
-import { ResponsesUsage$inboundSchema, ResponsesUsage$outboundSchema, } from "./responsesusage.js";
+import { ResponseTextConfig$inboundSchema, ResponseTextConfig$outboundSchema, } from "./responsetextconfig.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
 export const ObjectT = {
     Response: "response",
 };
@@ -29,14 +35,74 @@ export const Reason = {
     MaxOutputTokens: "max_output_tokens",
     ContentFilter: "content_filter",
 };
-export const ServiceTier = {
+export const InstructionsTypeFunctionCall = {
+    FunctionCall: "function_call",
+};
+export const InstructionsTypeFunctionCallOutput = {
+    FunctionCallOutput: "function_call_output",
+};
+export const InstructionsTypeMessage2 = {
+    Message: "message",
+};
+export const OpenResponsesNonStreamingResponseRoleDeveloper2 = {
+    Developer: "developer",
+};
+export const OpenResponsesNonStreamingResponseRoleSystem2 = {
+    System: "system",
+};
+export const OpenResponsesNonStreamingResponseRoleUser2 = {
+    User: "user",
+};
+export const InstructionsTypeMessage1 = {
+    Message: "message",
+};
+export const OpenResponsesNonStreamingResponseRoleDeveloper1 = {
+    Developer: "developer",
+};
+export const OpenResponsesNonStreamingResponseRoleAssistant = {
+    Assistant: "assistant",
+};
+export const OpenResponsesNonStreamingResponseRoleSystem1 = {
+    System: "system",
+};
+export const OpenResponsesNonStreamingResponseRoleUser1 = {
+    User: "user",
+};
+export const OpenResponsesNonStreamingResponseToolType = {
+    Function: "function",
+};
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview = {
+    WebSearchPreview: "web_search_preview",
+};
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311 = {
+    WebSearchPreview20250311: "web_search_preview_2025_03_11",
+};
+export const OpenResponsesNonStreamingResponseToolChoiceTypeFunction = {
+    Function: "function",
+};
+export const OpenResponsesNonStreamingResponseToolChoiceRequired = {
+    Required: "required",
+};
+export const OpenResponsesNonStreamingResponseToolChoiceNone = {
+    None: "none",
+};
+export const OpenResponsesNonStreamingResponseToolChoiceAuto = {
+    Auto: "auto",
+};
+export const OpenResponsesNonStreamingResponseEffort = {
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+    Minimal: "minimal",
+};
+export const OpenResponsesNonStreamingResponseServiceTier = {
     Auto: "auto",
     Default: "default",
     Flex: "flex",
     Priority: "priority",
     Scale: "scale",
 };
-export const Truncation = {
+export const OpenResponsesNonStreamingResponseTruncation = {
     Auto: "auto",
     Disabled: "disabled",
 };
@@ -127,52 +193,1158 @@ export function incompleteDetailsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => IncompleteDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'IncompleteDetails' from JSON`);
 }
 /** @internal */
-export const ServiceTier$inboundSchema = z
+export const InputTokensDetails$inboundSchema = z.object({
+    cached_tokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "cached_tokens": "cachedTokens",
+    });
+});
+/** @internal */
+export const InputTokensDetails$outboundSchema = z.object({
+    cachedTokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        cachedTokens: "cached_tokens",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InputTokensDetails$;
+(function (InputTokensDetails$) {
+    /** @deprecated use `InputTokensDetails$inboundSchema` instead. */
+    InputTokensDetails$.inboundSchema = InputTokensDetails$inboundSchema;
+    /** @deprecated use `InputTokensDetails$outboundSchema` instead. */
+    InputTokensDetails$.outboundSchema = InputTokensDetails$outboundSchema;
+})(InputTokensDetails$ || (InputTokensDetails$ = {}));
+export function inputTokensDetailsToJSON(inputTokensDetails) {
+    return JSON.stringify(InputTokensDetails$outboundSchema.parse(inputTokensDetails));
+}
+export function inputTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputTokensDetails' from JSON`);
+}
+/** @internal */
+export const OutputTokensDetails$inboundSchema = z.object({
+    reasoning_tokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "reasoning_tokens": "reasoningTokens",
+    });
+});
+/** @internal */
+export const OutputTokensDetails$outboundSchema = z.object({
+    reasoningTokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        reasoningTokens: "reasoning_tokens",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OutputTokensDetails$;
+(function (OutputTokensDetails$) {
+    /** @deprecated use `OutputTokensDetails$inboundSchema` instead. */
+    OutputTokensDetails$.inboundSchema = OutputTokensDetails$inboundSchema;
+    /** @deprecated use `OutputTokensDetails$outboundSchema` instead. */
+    OutputTokensDetails$.outboundSchema = OutputTokensDetails$outboundSchema;
+})(OutputTokensDetails$ || (OutputTokensDetails$ = {}));
+export function outputTokensDetailsToJSON(outputTokensDetails) {
+    return JSON.stringify(OutputTokensDetails$outboundSchema.parse(outputTokensDetails));
+}
+export function outputTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputTokensDetails' from JSON`);
+}
+/** @internal */
+export const Usage$inboundSchema = z
+    .object({
+    input_tokens: z.number(),
+    input_tokens_details: z.lazy(() => InputTokensDetails$inboundSchema),
+    output_tokens: z.number(),
+    output_tokens_details: z.lazy(() => OutputTokensDetails$inboundSchema),
+    total_tokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "input_tokens": "inputTokens",
+        "input_tokens_details": "inputTokensDetails",
+        "output_tokens": "outputTokens",
+        "output_tokens_details": "outputTokensDetails",
+        "total_tokens": "totalTokens",
+    });
+});
+/** @internal */
+export const Usage$outboundSchema = z.object({
+    inputTokens: z.number(),
+    inputTokensDetails: z.lazy(() => InputTokensDetails$outboundSchema),
+    outputTokens: z.number(),
+    outputTokensDetails: z.lazy(() => OutputTokensDetails$outboundSchema),
+    totalTokens: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        inputTokens: "input_tokens",
+        inputTokensDetails: "input_tokens_details",
+        outputTokens: "output_tokens",
+        outputTokensDetails: "output_tokens_details",
+        totalTokens: "total_tokens",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var Usage$;
+(function (Usage$) {
+    /** @deprecated use `Usage$inboundSchema` instead. */
+    Usage$.inboundSchema = Usage$inboundSchema;
+    /** @deprecated use `Usage$outboundSchema` instead. */
+    Usage$.outboundSchema = Usage$outboundSchema;
+})(Usage$ || (Usage$ = {}));
+export function usageToJSON(usage) {
+    return JSON.stringify(Usage$outboundSchema.parse(usage));
+}
+export function usageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Usage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Usage' from JSON`);
+}
+/** @internal */
+export const InstructionsTypeFunctionCall$inboundSchema = z.nativeEnum(InstructionsTypeFunctionCall);
+/** @internal */
+export const InstructionsTypeFunctionCall$outboundSchema = InstructionsTypeFunctionCall$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsTypeFunctionCall$;
+(function (InstructionsTypeFunctionCall$) {
+    /** @deprecated use `InstructionsTypeFunctionCall$inboundSchema` instead. */
+    InstructionsTypeFunctionCall$.inboundSchema = InstructionsTypeFunctionCall$inboundSchema;
+    /** @deprecated use `InstructionsTypeFunctionCall$outboundSchema` instead. */
+    InstructionsTypeFunctionCall$.outboundSchema = InstructionsTypeFunctionCall$outboundSchema;
+})(InstructionsTypeFunctionCall$ || (InstructionsTypeFunctionCall$ = {}));
+/** @internal */
+export const InstructionsFunctionCall$inboundSchema = z.object({
+    type: InstructionsTypeFunctionCall$inboundSchema,
+    call_id: z.string(),
+    name: z.string(),
+    arguments: z.string(),
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const InstructionsFunctionCall$outboundSchema = z.object({
+    type: InstructionsTypeFunctionCall$outboundSchema,
+    callId: z.string(),
+    name: z.string(),
+    arguments: z.string(),
+    id: z.string().optional(),
+    status: ToolCallStatus$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsFunctionCall$;
+(function (InstructionsFunctionCall$) {
+    /** @deprecated use `InstructionsFunctionCall$inboundSchema` instead. */
+    InstructionsFunctionCall$.inboundSchema = InstructionsFunctionCall$inboundSchema;
+    /** @deprecated use `InstructionsFunctionCall$outboundSchema` instead. */
+    InstructionsFunctionCall$.outboundSchema = InstructionsFunctionCall$outboundSchema;
+})(InstructionsFunctionCall$ || (InstructionsFunctionCall$ = {}));
+export function instructionsFunctionCallToJSON(instructionsFunctionCall) {
+    return JSON.stringify(InstructionsFunctionCall$outboundSchema.parse(instructionsFunctionCall));
+}
+export function instructionsFunctionCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InstructionsFunctionCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InstructionsFunctionCall' from JSON`);
+}
+/** @internal */
+export const InstructionsTypeFunctionCallOutput$inboundSchema = z.nativeEnum(InstructionsTypeFunctionCallOutput);
+/** @internal */
+export const InstructionsTypeFunctionCallOutput$outboundSchema = InstructionsTypeFunctionCallOutput$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsTypeFunctionCallOutput$;
+(function (InstructionsTypeFunctionCallOutput$) {
+    /** @deprecated use `InstructionsTypeFunctionCallOutput$inboundSchema` instead. */
+    InstructionsTypeFunctionCallOutput$.inboundSchema = InstructionsTypeFunctionCallOutput$inboundSchema;
+    /** @deprecated use `InstructionsTypeFunctionCallOutput$outboundSchema` instead. */
+    InstructionsTypeFunctionCallOutput$.outboundSchema = InstructionsTypeFunctionCallOutput$outboundSchema;
+})(InstructionsTypeFunctionCallOutput$ || (InstructionsTypeFunctionCallOutput$ = {}));
+/** @internal */
+export const InstructionsFunctionCallOutput$inboundSchema = z.object({
+    type: InstructionsTypeFunctionCallOutput$inboundSchema,
+    id: z.string(),
+    call_id: z.string(),
+    output: z.string(),
+    status: ToolCallStatus$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const InstructionsFunctionCallOutput$outboundSchema = z.object({
+    type: InstructionsTypeFunctionCallOutput$outboundSchema,
+    id: z.string(),
+    callId: z.string(),
+    output: z.string(),
+    status: ToolCallStatus$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsFunctionCallOutput$;
+(function (InstructionsFunctionCallOutput$) {
+    /** @deprecated use `InstructionsFunctionCallOutput$inboundSchema` instead. */
+    InstructionsFunctionCallOutput$.inboundSchema = InstructionsFunctionCallOutput$inboundSchema;
+    /** @deprecated use `InstructionsFunctionCallOutput$outboundSchema` instead. */
+    InstructionsFunctionCallOutput$.outboundSchema = InstructionsFunctionCallOutput$outboundSchema;
+})(InstructionsFunctionCallOutput$ || (InstructionsFunctionCallOutput$ = {}));
+export function instructionsFunctionCallOutputToJSON(instructionsFunctionCallOutput) {
+    return JSON.stringify(InstructionsFunctionCallOutput$outboundSchema.parse(instructionsFunctionCallOutput));
+}
+export function instructionsFunctionCallOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InstructionsFunctionCallOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InstructionsFunctionCallOutput' from JSON`);
+}
+/** @internal */
+export const InstructionsTypeMessage2$inboundSchema = z.nativeEnum(InstructionsTypeMessage2);
+/** @internal */
+export const InstructionsTypeMessage2$outboundSchema = InstructionsTypeMessage2$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsTypeMessage2$;
+(function (InstructionsTypeMessage2$) {
+    /** @deprecated use `InstructionsTypeMessage2$inboundSchema` instead. */
+    InstructionsTypeMessage2$.inboundSchema = InstructionsTypeMessage2$inboundSchema;
+    /** @deprecated use `InstructionsTypeMessage2$outboundSchema` instead. */
+    InstructionsTypeMessage2$.outboundSchema = InstructionsTypeMessage2$outboundSchema;
+})(InstructionsTypeMessage2$ || (InstructionsTypeMessage2$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleDeveloper2);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema = OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleDeveloper2$;
+(function (OpenResponsesNonStreamingResponseRoleDeveloper2$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleDeveloper2$.inboundSchema = OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleDeveloper2$.outboundSchema = OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleDeveloper2$ || (OpenResponsesNonStreamingResponseRoleDeveloper2$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleSystem2);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema = OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleSystem2$;
+(function (OpenResponsesNonStreamingResponseRoleSystem2$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleSystem2$.inboundSchema = OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleSystem2$.outboundSchema = OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleSystem2$ || (OpenResponsesNonStreamingResponseRoleSystem2$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser2$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleUser2);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser2$outboundSchema = OpenResponsesNonStreamingResponseRoleUser2$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleUser2$;
+(function (OpenResponsesNonStreamingResponseRoleUser2$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser2$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUser2$.inboundSchema = OpenResponsesNonStreamingResponseRoleUser2$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser2$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUser2$.outboundSchema = OpenResponsesNonStreamingResponseRoleUser2$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleUser2$ || (OpenResponsesNonStreamingResponseRoleUser2$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema = z.union([
+    OpenResponsesNonStreamingResponseRoleUser2$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema,
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema = z.union([
+    OpenResponsesNonStreamingResponseRoleUser2$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleUnion2$;
+(function (OpenResponsesNonStreamingResponseRoleUnion2$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUnion2$.inboundSchema = OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUnion2$.outboundSchema = OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleUnion2$ || (OpenResponsesNonStreamingResponseRoleUnion2$ = {}));
+export function openResponsesNonStreamingResponseRoleUnion2ToJSON(openResponsesNonStreamingResponseRoleUnion2) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseRoleUnion2$outboundSchema.parse(openResponsesNonStreamingResponseRoleUnion2));
+}
+export function openResponsesNonStreamingResponseRoleUnion2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseRoleUnion2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseRoleUnion2' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent3$inboundSchema = z.union([
+    ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+        type: v.type,
+    }))),
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent3$outboundSchema = z.union([
+    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+        type: v.type,
+    }))),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseContent3$;
+(function (OpenResponsesNonStreamingResponseContent3$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseContent3$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseContent3$.inboundSchema = OpenResponsesNonStreamingResponseContent3$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseContent3$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseContent3$.outboundSchema = OpenResponsesNonStreamingResponseContent3$outboundSchema;
+})(OpenResponsesNonStreamingResponseContent3$ || (OpenResponsesNonStreamingResponseContent3$ = {}));
+export function openResponsesNonStreamingResponseContent3ToJSON(openResponsesNonStreamingResponseContent3) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseContent3$outboundSchema.parse(openResponsesNonStreamingResponseContent3));
+}
+export function openResponsesNonStreamingResponseContent3FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseContent3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseContent3' from JSON`);
+}
+/** @internal */
+export const InstructionsMessage2$inboundSchema = z.object({
+    id: z.string(),
+    type: InstructionsTypeMessage2$inboundSchema.optional(),
+    role: z.union([
+        OpenResponsesNonStreamingResponseRoleUser2$inboundSchema,
+        OpenResponsesNonStreamingResponseRoleSystem2$inboundSchema,
+        OpenResponsesNonStreamingResponseRoleDeveloper2$inboundSchema,
+    ]),
+    content: z.array(z.union([
+        ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+        }))),
+    ])),
+});
+/** @internal */
+export const InstructionsMessage2$outboundSchema = z.object({
+    id: z.string(),
+    type: InstructionsTypeMessage2$outboundSchema.optional(),
+    role: z.union([
+        OpenResponsesNonStreamingResponseRoleUser2$outboundSchema,
+        OpenResponsesNonStreamingResponseRoleSystem2$outboundSchema,
+        OpenResponsesNonStreamingResponseRoleDeveloper2$outboundSchema,
+    ]),
+    content: z.array(z.union([
+        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+        }))),
+    ])),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsMessage2$;
+(function (InstructionsMessage2$) {
+    /** @deprecated use `InstructionsMessage2$inboundSchema` instead. */
+    InstructionsMessage2$.inboundSchema = InstructionsMessage2$inboundSchema;
+    /** @deprecated use `InstructionsMessage2$outboundSchema` instead. */
+    InstructionsMessage2$.outboundSchema = InstructionsMessage2$outboundSchema;
+})(InstructionsMessage2$ || (InstructionsMessage2$ = {}));
+export function instructionsMessage2ToJSON(instructionsMessage2) {
+    return JSON.stringify(InstructionsMessage2$outboundSchema.parse(instructionsMessage2));
+}
+export function instructionsMessage2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InstructionsMessage2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InstructionsMessage2' from JSON`);
+}
+/** @internal */
+export const InstructionsTypeMessage1$inboundSchema = z.nativeEnum(InstructionsTypeMessage1);
+/** @internal */
+export const InstructionsTypeMessage1$outboundSchema = InstructionsTypeMessage1$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsTypeMessage1$;
+(function (InstructionsTypeMessage1$) {
+    /** @deprecated use `InstructionsTypeMessage1$inboundSchema` instead. */
+    InstructionsTypeMessage1$.inboundSchema = InstructionsTypeMessage1$inboundSchema;
+    /** @deprecated use `InstructionsTypeMessage1$outboundSchema` instead. */
+    InstructionsTypeMessage1$.outboundSchema = InstructionsTypeMessage1$outboundSchema;
+})(InstructionsTypeMessage1$ || (InstructionsTypeMessage1$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleDeveloper1);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema = OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleDeveloper1$;
+(function (OpenResponsesNonStreamingResponseRoleDeveloper1$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleDeveloper1$.inboundSchema = OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleDeveloper1$.outboundSchema = OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleDeveloper1$ || (OpenResponsesNonStreamingResponseRoleDeveloper1$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleAssistant);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema = OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleAssistant$;
+(function (OpenResponsesNonStreamingResponseRoleAssistant$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleAssistant$.inboundSchema = OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleAssistant$.outboundSchema = OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleAssistant$ || (OpenResponsesNonStreamingResponseRoleAssistant$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleSystem1);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema = OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleSystem1$;
+(function (OpenResponsesNonStreamingResponseRoleSystem1$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleSystem1$.inboundSchema = OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleSystem1$.outboundSchema = OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleSystem1$ || (OpenResponsesNonStreamingResponseRoleSystem1$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser1$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseRoleUser1);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUser1$outboundSchema = OpenResponsesNonStreamingResponseRoleUser1$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleUser1$;
+(function (OpenResponsesNonStreamingResponseRoleUser1$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser1$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUser1$.inboundSchema = OpenResponsesNonStreamingResponseRoleUser1$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUser1$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUser1$.outboundSchema = OpenResponsesNonStreamingResponseRoleUser1$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleUser1$ || (OpenResponsesNonStreamingResponseRoleUser1$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema = z.union([
+    OpenResponsesNonStreamingResponseRoleUser1$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema,
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema = z.union([
+    OpenResponsesNonStreamingResponseRoleUser1$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema,
+    OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseRoleUnion1$;
+(function (OpenResponsesNonStreamingResponseRoleUnion1$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUnion1$.inboundSchema = OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseRoleUnion1$.outboundSchema = OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema;
+})(OpenResponsesNonStreamingResponseRoleUnion1$ || (OpenResponsesNonStreamingResponseRoleUnion1$ = {}));
+export function openResponsesNonStreamingResponseRoleUnion1ToJSON(openResponsesNonStreamingResponseRoleUnion1) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseRoleUnion1$outboundSchema.parse(openResponsesNonStreamingResponseRoleUnion1));
+}
+export function openResponsesNonStreamingResponseRoleUnion1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseRoleUnion1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseRoleUnion1' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent1$inboundSchema = z.union([
+    ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+        type: v.type,
+    }))),
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent1$outboundSchema = z.union([
+    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+        type: v.type,
+    }))),
+    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+        type: v.type,
+    }))),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseContent1$;
+(function (OpenResponsesNonStreamingResponseContent1$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseContent1$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseContent1$.inboundSchema = OpenResponsesNonStreamingResponseContent1$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseContent1$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseContent1$.outboundSchema = OpenResponsesNonStreamingResponseContent1$outboundSchema;
+})(OpenResponsesNonStreamingResponseContent1$ || (OpenResponsesNonStreamingResponseContent1$ = {}));
+export function openResponsesNonStreamingResponseContent1ToJSON(openResponsesNonStreamingResponseContent1) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseContent1$outboundSchema.parse(openResponsesNonStreamingResponseContent1));
+}
+export function openResponsesNonStreamingResponseContent1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseContent1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseContent1' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent2$inboundSchema = z.union([
+    z.array(z.union([
+        ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+        }))),
+    ])),
+    z.string(),
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseContent2$outboundSchema = z.union([
+    z.array(z.union([
+        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+            type: v.type,
+        }))),
+        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+            type: v.type,
+        }))),
+    ])),
+    z.string(),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseContent2$;
+(function (OpenResponsesNonStreamingResponseContent2$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseContent2$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseContent2$.inboundSchema = OpenResponsesNonStreamingResponseContent2$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseContent2$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseContent2$.outboundSchema = OpenResponsesNonStreamingResponseContent2$outboundSchema;
+})(OpenResponsesNonStreamingResponseContent2$ || (OpenResponsesNonStreamingResponseContent2$ = {}));
+export function openResponsesNonStreamingResponseContent2ToJSON(openResponsesNonStreamingResponseContent2) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseContent2$outboundSchema.parse(openResponsesNonStreamingResponseContent2));
+}
+export function openResponsesNonStreamingResponseContent2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseContent2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseContent2' from JSON`);
+}
+/** @internal */
+export const InstructionsMessage1$inboundSchema = z.object({
+    type: InstructionsTypeMessage1$inboundSchema.optional(),
+    role: z.union([
+        OpenResponsesNonStreamingResponseRoleUser1$inboundSchema,
+        OpenResponsesNonStreamingResponseRoleSystem1$inboundSchema,
+        OpenResponsesNonStreamingResponseRoleAssistant$inboundSchema,
+        OpenResponsesNonStreamingResponseRoleDeveloper1$inboundSchema,
+    ]),
+    content: z.union([
+        z.array(z.union([
+            ResponseInputText$inboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+                type: v.type,
+            }))),
+            ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+                type: v.type,
+            }))),
+            ResponseInputFile$inboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+                type: v.type,
+            }))),
+        ])),
+        z.string(),
+    ]),
+});
+/** @internal */
+export const InstructionsMessage1$outboundSchema = z.object({
+    type: InstructionsTypeMessage1$outboundSchema.optional(),
+    role: z.union([
+        OpenResponsesNonStreamingResponseRoleUser1$outboundSchema,
+        OpenResponsesNonStreamingResponseRoleSystem1$outboundSchema,
+        OpenResponsesNonStreamingResponseRoleAssistant$outboundSchema,
+        OpenResponsesNonStreamingResponseRoleDeveloper1$outboundSchema,
+    ]),
+    content: z.union([
+        z.array(z.union([
+            ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") }).transform((v) => ({
+                type: v.type,
+            }))),
+            ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") }).transform((v) => ({
+                type: v.type,
+            }))),
+            ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") }).transform((v) => ({
+                type: v.type,
+            }))),
+        ])),
+        z.string(),
+    ]),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsMessage1$;
+(function (InstructionsMessage1$) {
+    /** @deprecated use `InstructionsMessage1$inboundSchema` instead. */
+    InstructionsMessage1$.inboundSchema = InstructionsMessage1$inboundSchema;
+    /** @deprecated use `InstructionsMessage1$outboundSchema` instead. */
+    InstructionsMessage1$.outboundSchema = InstructionsMessage1$outboundSchema;
+})(InstructionsMessage1$ || (InstructionsMessage1$ = {}));
+export function instructionsMessage1ToJSON(instructionsMessage1) {
+    return JSON.stringify(InstructionsMessage1$outboundSchema.parse(instructionsMessage1));
+}
+export function instructionsMessage1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InstructionsMessage1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InstructionsMessage1' from JSON`);
+}
+/** @internal */
+export const InstructionsUnion1$inboundSchema = z.union([
+    z.lazy(() => InstructionsFunctionCallOutput$inboundSchema),
+    z.lazy(() => InstructionsFunctionCall$inboundSchema),
+    OutputItemImageGenerationCall$inboundSchema,
+    OutputMessage$inboundSchema,
+    z.lazy(() => InstructionsMessage2$inboundSchema),
+    z.lazy(() => InstructionsMessage1$inboundSchema),
+]);
+/** @internal */
+export const InstructionsUnion1$outboundSchema = z.union([
+    z.lazy(() => InstructionsFunctionCallOutput$outboundSchema),
+    z.lazy(() => InstructionsFunctionCall$outboundSchema),
+    OutputItemImageGenerationCall$outboundSchema,
+    OutputMessage$outboundSchema,
+    z.lazy(() => InstructionsMessage2$outboundSchema),
+    z.lazy(() => InstructionsMessage1$outboundSchema),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsUnion1$;
+(function (InstructionsUnion1$) {
+    /** @deprecated use `InstructionsUnion1$inboundSchema` instead. */
+    InstructionsUnion1$.inboundSchema = InstructionsUnion1$inboundSchema;
+    /** @deprecated use `InstructionsUnion1$outboundSchema` instead. */
+    InstructionsUnion1$.outboundSchema = InstructionsUnion1$outboundSchema;
+})(InstructionsUnion1$ || (InstructionsUnion1$ = {}));
+export function instructionsUnion1ToJSON(instructionsUnion1) {
+    return JSON.stringify(InstructionsUnion1$outboundSchema.parse(instructionsUnion1));
+}
+export function instructionsUnion1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InstructionsUnion1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InstructionsUnion1' from JSON`);
+}
+/** @internal */
+export const InstructionsUnion2$inboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        z.lazy(() => InstructionsFunctionCallOutput$inboundSchema),
+        z.lazy(() => InstructionsFunctionCall$inboundSchema),
+        OutputItemImageGenerationCall$inboundSchema,
+        OutputMessage$inboundSchema,
+        z.lazy(() => InstructionsMessage2$inboundSchema),
+        z.lazy(() => InstructionsMessage1$inboundSchema),
+    ])),
+    z.any(),
+]);
+/** @internal */
+export const InstructionsUnion2$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        z.lazy(() => InstructionsFunctionCallOutput$outboundSchema),
+        z.lazy(() => InstructionsFunctionCall$outboundSchema),
+        OutputItemImageGenerationCall$outboundSchema,
+        OutputMessage$outboundSchema,
+        z.lazy(() => InstructionsMessage2$outboundSchema),
+        z.lazy(() => InstructionsMessage1$outboundSchema),
+    ])),
+    z.any(),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var InstructionsUnion2$;
+(function (InstructionsUnion2$) {
+    /** @deprecated use `InstructionsUnion2$inboundSchema` instead. */
+    InstructionsUnion2$.inboundSchema = InstructionsUnion2$inboundSchema;
+    /** @deprecated use `InstructionsUnion2$outboundSchema` instead. */
+    InstructionsUnion2$.outboundSchema = InstructionsUnion2$outboundSchema;
+})(InstructionsUnion2$ || (InstructionsUnion2$ = {}));
+export function instructionsUnion2ToJSON(instructionsUnion2) {
+    return JSON.stringify(InstructionsUnion2$outboundSchema.parse(instructionsUnion2));
+}
+export function instructionsUnion2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InstructionsUnion2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InstructionsUnion2' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolType$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseToolType);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolType$outboundSchema = OpenResponsesNonStreamingResponseToolType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolType$;
+(function (OpenResponsesNonStreamingResponseToolType$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolType$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolType$.inboundSchema = OpenResponsesNonStreamingResponseToolType$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolType$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolType$.outboundSchema = OpenResponsesNonStreamingResponseToolType$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolType$ || (OpenResponsesNonStreamingResponseToolType$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolFunction$inboundSchema = z.object({
+    type: OpenResponsesNonStreamingResponseToolType$inboundSchema,
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.nullable(z.any()))),
+});
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolFunction$outboundSchema = z.object({
+    type: OpenResponsesNonStreamingResponseToolType$outboundSchema,
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.nullable(z.any()))),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolFunction$;
+(function (OpenResponsesNonStreamingResponseToolFunction$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolFunction$.inboundSchema = OpenResponsesNonStreamingResponseToolFunction$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolFunction$.outboundSchema = OpenResponsesNonStreamingResponseToolFunction$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolFunction$ || (OpenResponsesNonStreamingResponseToolFunction$ = {}));
+export function openResponsesNonStreamingResponseToolFunctionToJSON(openResponsesNonStreamingResponseToolFunction) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseToolFunction$outboundSchema.parse(openResponsesNonStreamingResponseToolFunction));
+}
+export function openResponsesNonStreamingResponseToolFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseToolFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseToolFunction' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolUnion$inboundSchema = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$inboundSchema),
+    OpenResponsesWebSearchPreviewTool$inboundSchema,
+    OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+    OpenResponsesWebSearchTool$inboundSchema,
+    OpenResponsesWebSearch20250826Tool$inboundSchema,
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$outboundSchema),
+    OpenResponsesWebSearchPreviewTool$outboundSchema,
+    OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+    OpenResponsesWebSearchTool$outboundSchema,
+    OpenResponsesWebSearch20250826Tool$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolUnion$;
+(function (OpenResponsesNonStreamingResponseToolUnion$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolUnion$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolUnion$.inboundSchema = OpenResponsesNonStreamingResponseToolUnion$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolUnion$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolUnion$.outboundSchema = OpenResponsesNonStreamingResponseToolUnion$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolUnion$ || (OpenResponsesNonStreamingResponseToolUnion$ = {}));
+export function openResponsesNonStreamingResponseToolUnionToJSON(openResponsesNonStreamingResponseToolUnion) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseToolUnion$outboundSchema.parse(openResponsesNonStreamingResponseToolUnion));
+}
+export function openResponsesNonStreamingResponseToolUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseToolUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseToolUnion' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema = z.nativeEnum(OpenResponsesNonStreamingResponseTypeWebSearchPreview);
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema = OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseTypeWebSearchPreview$;
+(function (OpenResponsesNonStreamingResponseTypeWebSearchPreview$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$.inboundSchema = OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$.outboundSchema = OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema;
+})(OpenResponsesNonStreamingResponseTypeWebSearchPreview$ || (OpenResponsesNonStreamingResponseTypeWebSearchPreview$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema = z.nativeEnum(OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311);
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema = OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$;
+(function (OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$.inboundSchema = OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$.outboundSchema = OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema;
+})(OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$ || (OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeUnion$inboundSchema = z.union([
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema,
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema,
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseTypeUnion$outboundSchema = z.union([
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema,
+    OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseTypeUnion$;
+(function (OpenResponsesNonStreamingResponseTypeUnion$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseTypeUnion$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTypeUnion$.inboundSchema = OpenResponsesNonStreamingResponseTypeUnion$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseTypeUnion$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTypeUnion$.outboundSchema = OpenResponsesNonStreamingResponseTypeUnion$outboundSchema;
+})(OpenResponsesNonStreamingResponseTypeUnion$ || (OpenResponsesNonStreamingResponseTypeUnion$ = {}));
+export function openResponsesNonStreamingResponseTypeUnionToJSON(openResponsesNonStreamingResponseTypeUnion) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseTypeUnion$outboundSchema.parse(openResponsesNonStreamingResponseTypeUnion));
+}
+export function openResponsesNonStreamingResponseTypeUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseTypeUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseTypeUnion' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoice$inboundSchema = z.object({
+    type: z.union([
+        OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$inboundSchema,
+        OpenResponsesNonStreamingResponseTypeWebSearchPreview$inboundSchema,
+    ]),
+});
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoice$outboundSchema = z.object({
+    type: z.union([
+        OpenResponsesNonStreamingResponseTypeWebSearchPreview20250311$outboundSchema,
+        OpenResponsesNonStreamingResponseTypeWebSearchPreview$outboundSchema,
+    ]),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoice$;
+(function (OpenResponsesNonStreamingResponseToolChoice$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoice$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoice$.inboundSchema = OpenResponsesNonStreamingResponseToolChoice$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoice$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoice$.outboundSchema = OpenResponsesNonStreamingResponseToolChoice$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoice$ || (OpenResponsesNonStreamingResponseToolChoice$ = {}));
+export function openResponsesNonStreamingResponseToolChoiceToJSON(openResponsesNonStreamingResponseToolChoice) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseToolChoice$outboundSchema.parse(openResponsesNonStreamingResponseToolChoice));
+}
+export function openResponsesNonStreamingResponseToolChoiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseToolChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseToolChoice' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema = z.nativeEnum(OpenResponsesNonStreamingResponseToolChoiceTypeFunction);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema = OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoiceTypeFunction$;
+(function (OpenResponsesNonStreamingResponseToolChoiceTypeFunction$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceTypeFunction$.inboundSchema = OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceTypeFunction$.outboundSchema = OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoiceTypeFunction$ || (OpenResponsesNonStreamingResponseToolChoiceTypeFunction$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema = z.object({
+    type: OpenResponsesNonStreamingResponseToolChoiceTypeFunction$inboundSchema,
+    name: z.string(),
+});
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema = z.object({
+    type: OpenResponsesNonStreamingResponseToolChoiceTypeFunction$outboundSchema,
+    name: z.string(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoiceFunction$;
+(function (OpenResponsesNonStreamingResponseToolChoiceFunction$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceFunction$.inboundSchema = OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceFunction$.outboundSchema = OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoiceFunction$ || (OpenResponsesNonStreamingResponseToolChoiceFunction$ = {}));
+export function openResponsesNonStreamingResponseToolChoiceFunctionToJSON(openResponsesNonStreamingResponseToolChoiceFunction) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema.parse(openResponsesNonStreamingResponseToolChoiceFunction));
+}
+export function openResponsesNonStreamingResponseToolChoiceFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseToolChoiceFunction' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema = z.nativeEnum(OpenResponsesNonStreamingResponseToolChoiceRequired);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema = OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoiceRequired$;
+(function (OpenResponsesNonStreamingResponseToolChoiceRequired$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceRequired$.inboundSchema = OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceRequired$.outboundSchema = OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoiceRequired$ || (OpenResponsesNonStreamingResponseToolChoiceRequired$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseToolChoiceNone);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema = OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoiceNone$;
+(function (OpenResponsesNonStreamingResponseToolChoiceNone$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceNone$.inboundSchema = OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceNone$.outboundSchema = OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoiceNone$ || (OpenResponsesNonStreamingResponseToolChoiceNone$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema = z
+    .nativeEnum(OpenResponsesNonStreamingResponseToolChoiceAuto);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema = OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoiceAuto$;
+(function (OpenResponsesNonStreamingResponseToolChoiceAuto$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceAuto$.inboundSchema = OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceAuto$.outboundSchema = OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoiceAuto$ || (OpenResponsesNonStreamingResponseToolChoiceAuto$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema),
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$inboundSchema),
+    OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema,
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema),
+    z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$outboundSchema),
+    OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema,
+    OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolChoiceUnion$;
+(function (OpenResponsesNonStreamingResponseToolChoiceUnion$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceUnion$.inboundSchema = OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolChoiceUnion$.outboundSchema = OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolChoiceUnion$ || (OpenResponsesNonStreamingResponseToolChoiceUnion$ = {}));
+export function openResponsesNonStreamingResponseToolChoiceUnionToJSON(openResponsesNonStreamingResponseToolChoiceUnion) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseToolChoiceUnion$outboundSchema.parse(openResponsesNonStreamingResponseToolChoiceUnion));
+}
+export function openResponsesNonStreamingResponseToolChoiceUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseToolChoiceUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseToolChoiceUnion' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseEffort$inboundSchema = z
     .union([
-    z.nativeEnum(ServiceTier),
+    z.nativeEnum(OpenResponsesNonStreamingResponseEffort),
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const ServiceTier$outboundSchema = z.union([
-    z.nativeEnum(ServiceTier),
+export const OpenResponsesNonStreamingResponseEffort$outboundSchema = z.union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseEffort),
     z.string().and(z.custom()),
 ]);
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var ServiceTier$;
-(function (ServiceTier$) {
-    /** @deprecated use `ServiceTier$inboundSchema` instead. */
-    ServiceTier$.inboundSchema = ServiceTier$inboundSchema;
-    /** @deprecated use `ServiceTier$outboundSchema` instead. */
-    ServiceTier$.outboundSchema = ServiceTier$outboundSchema;
-})(ServiceTier$ || (ServiceTier$ = {}));
+export var OpenResponsesNonStreamingResponseEffort$;
+(function (OpenResponsesNonStreamingResponseEffort$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseEffort$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseEffort$.inboundSchema = OpenResponsesNonStreamingResponseEffort$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseEffort$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseEffort$.outboundSchema = OpenResponsesNonStreamingResponseEffort$outboundSchema;
+})(OpenResponsesNonStreamingResponseEffort$ || (OpenResponsesNonStreamingResponseEffort$ = {}));
 /** @internal */
-export const Truncation$inboundSchema = z
+export const OpenResponsesNonStreamingResponseReasoning$inboundSchema = z.object({
+    effort: z.nullable(OpenResponsesNonStreamingResponseEffort$inboundSchema)
+        .optional(),
+    summary: ReasoningSummaryVerbosity$inboundSchema.optional(),
+});
+/** @internal */
+export const OpenResponsesNonStreamingResponseReasoning$outboundSchema = z.object({
+    effort: z.nullable(OpenResponsesNonStreamingResponseEffort$outboundSchema)
+        .optional(),
+    summary: ReasoningSummaryVerbosity$outboundSchema.optional(),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseReasoning$;
+(function (OpenResponsesNonStreamingResponseReasoning$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseReasoning$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseReasoning$.inboundSchema = OpenResponsesNonStreamingResponseReasoning$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseReasoning$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseReasoning$.outboundSchema = OpenResponsesNonStreamingResponseReasoning$outboundSchema;
+})(OpenResponsesNonStreamingResponseReasoning$ || (OpenResponsesNonStreamingResponseReasoning$ = {}));
+export function openResponsesNonStreamingResponseReasoningToJSON(openResponsesNonStreamingResponseReasoning) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseReasoning$outboundSchema.parse(openResponsesNonStreamingResponseReasoning));
+}
+export function openResponsesNonStreamingResponseReasoningFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseReasoning$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseReasoning' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponseServiceTier$inboundSchema = z
     .union([
-    z.nativeEnum(Truncation),
+    z.nativeEnum(OpenResponsesNonStreamingResponseServiceTier),
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const Truncation$outboundSchema = z.union([
-    z.nativeEnum(Truncation),
+export const OpenResponsesNonStreamingResponseServiceTier$outboundSchema = z.union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseServiceTier),
     z.string().and(z.custom()),
 ]);
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var Truncation$;
-(function (Truncation$) {
-    /** @deprecated use `Truncation$inboundSchema` instead. */
-    Truncation$.inboundSchema = Truncation$inboundSchema;
-    /** @deprecated use `Truncation$outboundSchema` instead. */
-    Truncation$.outboundSchema = Truncation$outboundSchema;
-})(Truncation$ || (Truncation$ = {}));
+export var OpenResponsesNonStreamingResponseServiceTier$;
+(function (OpenResponsesNonStreamingResponseServiceTier$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseServiceTier$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseServiceTier$.inboundSchema = OpenResponsesNonStreamingResponseServiceTier$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseServiceTier$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseServiceTier$.outboundSchema = OpenResponsesNonStreamingResponseServiceTier$outboundSchema;
+})(OpenResponsesNonStreamingResponseServiceTier$ || (OpenResponsesNonStreamingResponseServiceTier$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseTruncation$inboundSchema = z
+    .union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseTruncation),
+    z.string().transform(catchUnrecognizedEnum),
+]);
+/** @internal */
+export const OpenResponsesNonStreamingResponseTruncation$outboundSchema = z.union([
+    z.nativeEnum(OpenResponsesNonStreamingResponseTruncation),
+    z.string().and(z.custom()),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseTruncation$;
+(function (OpenResponsesNonStreamingResponseTruncation$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseTruncation$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTruncation$.inboundSchema = OpenResponsesNonStreamingResponseTruncation$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseTruncation$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseTruncation$.outboundSchema = OpenResponsesNonStreamingResponseTruncation$outboundSchema;
+})(OpenResponsesNonStreamingResponseTruncation$ || (OpenResponsesNonStreamingResponseTruncation$ = {}));
 /** @internal */
 export const OpenResponsesNonStreamingResponse$inboundSchema = z.object({
-    id: z.string().optional(),
+    id: z.string(),
     object: ObjectT$inboundSchema,
     created_at: z.number(),
     model: z.string(),
@@ -184,25 +1356,48 @@ export const OpenResponsesNonStreamingResponse$inboundSchema = z.object({
     safety_identifier: z.nullable(z.string()).optional(),
     error: z.nullable(ResponsesErrorField$inboundSchema),
     incomplete_details: z.nullable(z.lazy(() => IncompleteDetails$inboundSchema)),
-    usage: ResponsesUsage$inboundSchema.optional(),
+    usage: z.lazy(() => Usage$inboundSchema).optional(),
     max_tool_calls: z.nullable(z.number()).optional(),
     top_logprobs: z.number().optional(),
     max_output_tokens: z.nullable(z.number()).optional(),
     temperature: z.nullable(z.number()),
     top_p: z.nullable(z.number()),
-    instructions: z.nullable(OpenResponsesInput$inboundSchema).optional(),
+    instructions: z.nullable(z.union([
+        z.string(),
+        z.array(z.union([
+            z.lazy(() => InstructionsFunctionCallOutput$inboundSchema),
+            z.lazy(() => InstructionsFunctionCall$inboundSchema),
+            OutputItemImageGenerationCall$inboundSchema,
+            OutputMessage$inboundSchema,
+            z.lazy(() => InstructionsMessage2$inboundSchema),
+            z.lazy(() => InstructionsMessage1$inboundSchema),
+        ])),
+        z.any(),
+    ])).optional(),
     metadata: z.nullable(z.record(z.string())),
-    tools: z.array(OpenResponsesToolUnion$inboundSchema),
-    tool_choice: OpenResponsesToolChoice$inboundSchema,
+    tools: z.array(z.union([
+        z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$inboundSchema),
+        OpenResponsesWebSearchPreviewTool$inboundSchema,
+        OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+        OpenResponsesWebSearchTool$inboundSchema,
+        OpenResponsesWebSearch20250826Tool$inboundSchema,
+    ])),
+    tool_choice: z.union([
+        z.lazy(() => OpenResponsesNonStreamingResponseToolChoiceFunction$inboundSchema),
+        z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$inboundSchema),
+        OpenResponsesNonStreamingResponseToolChoiceAuto$inboundSchema,
+        OpenResponsesNonStreamingResponseToolChoiceNone$inboundSchema,
+        OpenResponsesNonStreamingResponseToolChoiceRequired$inboundSchema,
+    ]),
     parallel_tool_calls: z.boolean(),
-    prompt: z.nullable(OpenResponsesPrompt$inboundSchema).optional(),
+    prompt: z.nullable(OpenAIResponsesPrompt$inboundSchema).optional(),
     background: z.nullable(z.boolean()).optional(),
     previous_response_id: z.nullable(z.string()).optional(),
-    reasoning: z.nullable(OpenResponsesReasoningConfig$inboundSchema).optional(),
-    service_tier: z.nullable(ServiceTier$inboundSchema).optional(),
+    reasoning: z.nullable(z.lazy(() => OpenResponsesNonStreamingResponseReasoning$inboundSchema)).optional(),
+    service_tier: z.nullable(OpenResponsesNonStreamingResponseServiceTier$inboundSchema).optional(),
     store: z.boolean().optional(),
-    truncation: z.nullable(Truncation$inboundSchema).optional(),
-    text: OpenResponsesTextConfig$inboundSchema.optional(),
+    truncation: z.nullable(OpenResponsesNonStreamingResponseTruncation$inboundSchema).optional(),
+    text: ResponseTextConfig$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         "created_at": "createdAt",
@@ -222,7 +1417,7 @@ export const OpenResponsesNonStreamingResponse$inboundSchema = z.object({
 });
 /** @internal */
 export const OpenResponsesNonStreamingResponse$outboundSchema = z.object({
-    id: z.string().optional(),
+    id: z.string(),
     object: ObjectT$outboundSchema,
     createdAt: z.number(),
     model: z.string(),
@@ -234,25 +1429,48 @@ export const OpenResponsesNonStreamingResponse$outboundSchema = z.object({
     safetyIdentifier: z.nullable(z.string()).optional(),
     error: z.nullable(ResponsesErrorField$outboundSchema),
     incompleteDetails: z.nullable(z.lazy(() => IncompleteDetails$outboundSchema)),
-    usage: ResponsesUsage$outboundSchema.optional(),
+    usage: z.lazy(() => Usage$outboundSchema).optional(),
     maxToolCalls: z.nullable(z.number()).optional(),
     topLogprobs: z.number().optional(),
     maxOutputTokens: z.nullable(z.number()).optional(),
     temperature: z.nullable(z.number()),
     topP: z.nullable(z.number()),
-    instructions: z.nullable(OpenResponsesInput$outboundSchema).optional(),
+    instructions: z.nullable(z.union([
+        z.string(),
+        z.array(z.union([
+            z.lazy(() => InstructionsFunctionCallOutput$outboundSchema),
+            z.lazy(() => InstructionsFunctionCall$outboundSchema),
+            OutputItemImageGenerationCall$outboundSchema,
+            OutputMessage$outboundSchema,
+            z.lazy(() => InstructionsMessage2$outboundSchema),
+            z.lazy(() => InstructionsMessage1$outboundSchema),
+        ])),
+        z.any(),
+    ])).optional(),
     metadata: z.nullable(z.record(z.string())),
-    tools: z.array(OpenResponsesToolUnion$outboundSchema),
-    toolChoice: OpenResponsesToolChoice$outboundSchema,
+    tools: z.array(z.union([
+        z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$outboundSchema),
+        OpenResponsesWebSearchPreviewTool$outboundSchema,
+        OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+        OpenResponsesWebSearchTool$outboundSchema,
+        OpenResponsesWebSearch20250826Tool$outboundSchema,
+    ])),
+    toolChoice: z.union([
+        z.lazy(() => OpenResponsesNonStreamingResponseToolChoiceFunction$outboundSchema),
+        z.lazy(() => OpenResponsesNonStreamingResponseToolChoice$outboundSchema),
+        OpenResponsesNonStreamingResponseToolChoiceAuto$outboundSchema,
+        OpenResponsesNonStreamingResponseToolChoiceNone$outboundSchema,
+        OpenResponsesNonStreamingResponseToolChoiceRequired$outboundSchema,
+    ]),
     parallelToolCalls: z.boolean(),
-    prompt: z.nullable(OpenResponsesPrompt$outboundSchema).optional(),
+    prompt: z.nullable(OpenAIResponsesPrompt$outboundSchema).optional(),
     background: z.nullable(z.boolean()).optional(),
     previousResponseId: z.nullable(z.string()).optional(),
-    reasoning: z.nullable(OpenResponsesReasoningConfig$outboundSchema).optional(),
-    serviceTier: z.nullable(ServiceTier$outboundSchema).optional(),
+    reasoning: z.nullable(z.lazy(() => OpenResponsesNonStreamingResponseReasoning$outboundSchema)).optional(),
+    serviceTier: z.nullable(OpenResponsesNonStreamingResponseServiceTier$outboundSchema).optional(),
     store: z.boolean().optional(),
-    truncation: z.nullable(Truncation$outboundSchema).optional(),
-    text: OpenResponsesTextConfig$outboundSchema.optional(),
+    truncation: z.nullable(OpenResponsesNonStreamingResponseTruncation$outboundSchema).optional(),
+    text: ResponseTextConfig$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         createdAt: "created_at",