@openrouter/sdk 0.9.11 → 0.10.2

package/esm/models/openresponsesimagegenerationtool.d.ts

@@ -0,0 +1,125 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Background: {
+    readonly Transparent: "transparent";
+    readonly Opaque: "opaque";
+    readonly Auto: "auto";
+};
+export type Background = OpenEnum<typeof Background>;
+export declare const InputFidelity: {
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type InputFidelity = OpenEnum<typeof InputFidelity>;
+export type InputImageMask = {
+    imageUrl?: string | undefined;
+    fileId?: string | undefined;
+};
+export declare const ModelEnum: {
+    readonly GptImage1: "gpt-image-1";
+    readonly GptImage1Mini: "gpt-image-1-mini";
+};
+export type ModelEnum = OpenEnum<typeof ModelEnum>;
+export declare const Moderation: {
+    readonly Auto: "auto";
+    readonly Low: "low";
+};
+export type Moderation = OpenEnum<typeof Moderation>;
+export declare const OutputFormat: {
+    readonly Png: "png";
+    readonly Webp: "webp";
+    readonly Jpeg: "jpeg";
+};
+export type OutputFormat = OpenEnum<typeof OutputFormat>;
+export declare const Quality: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Auto: "auto";
+};
+export type Quality = OpenEnum<typeof Quality>;
+export declare const Size: {
+    readonly OneThousandAndTwentyFourx1024: "1024x1024";
+    readonly OneThousandAndTwentyFourx1536: "1024x1536";
+    readonly OneThousandFiveHundredAndThirtySixx1024: "1536x1024";
+    readonly Auto: "auto";
+};
+export type Size = OpenEnum<typeof Size>;
+/**
+ * Image generation tool configuration
+ */
+export type OpenResponsesImageGenerationTool = {
+    type: "image_generation";
+    background?: Background | undefined;
+    inputFidelity?: InputFidelity | null | undefined;
+    inputImageMask?: InputImageMask | undefined;
+    model?: ModelEnum | undefined;
+    moderation?: Moderation | undefined;
+    outputCompression?: number | undefined;
+    outputFormat?: OutputFormat | undefined;
+    partialImages?: number | undefined;
+    quality?: Quality | undefined;
+    size?: Size | undefined;
+};
+/** @internal */
+export declare const Background$inboundSchema: z.ZodType<Background, unknown>;
+/** @internal */
+export declare const Background$outboundSchema: z.ZodType<string, Background>;
+/** @internal */
+export declare const InputFidelity$inboundSchema: z.ZodType<InputFidelity, unknown>;
+/** @internal */
+export declare const InputFidelity$outboundSchema: z.ZodType<string, InputFidelity>;
+/** @internal */
+export declare const InputImageMask$inboundSchema: z.ZodType<InputImageMask, unknown>;
+/** @internal */
+export type InputImageMask$Outbound = {
+    image_url?: string | undefined;
+    file_id?: string | undefined;
+};
+/** @internal */
+export declare const InputImageMask$outboundSchema: z.ZodType<InputImageMask$Outbound, InputImageMask>;
+export declare function inputImageMaskToJSON(inputImageMask: InputImageMask): string;
+export declare function inputImageMaskFromJSON(jsonString: string): SafeParseResult<InputImageMask, SDKValidationError>;
+/** @internal */
+export declare const ModelEnum$inboundSchema: z.ZodType<ModelEnum, unknown>;
+/** @internal */
+export declare const ModelEnum$outboundSchema: z.ZodType<string, ModelEnum>;
+/** @internal */
+export declare const Moderation$inboundSchema: z.ZodType<Moderation, unknown>;
+/** @internal */
+export declare const Moderation$outboundSchema: z.ZodType<string, Moderation>;
+/** @internal */
+export declare const OutputFormat$inboundSchema: z.ZodType<OutputFormat, unknown>;
+/** @internal */
+export declare const OutputFormat$outboundSchema: z.ZodType<string, OutputFormat>;
+/** @internal */
+export declare const Quality$inboundSchema: z.ZodType<Quality, unknown>;
+/** @internal */
+export declare const Quality$outboundSchema: z.ZodType<string, Quality>;
+/** @internal */
+export declare const Size$inboundSchema: z.ZodType<Size, unknown>;
+/** @internal */
+export declare const Size$outboundSchema: z.ZodType<string, Size>;
+/** @internal */
+export declare const OpenResponsesImageGenerationTool$inboundSchema: z.ZodType<OpenResponsesImageGenerationTool, unknown>;
+/** @internal */
+export type OpenResponsesImageGenerationTool$Outbound = {
+    type: "image_generation";
+    background?: string | undefined;
+    input_fidelity?: string | null | undefined;
+    input_image_mask?: InputImageMask$Outbound | undefined;
+    model?: string | undefined;
+    moderation?: string | undefined;
+    output_compression?: number | undefined;
+    output_format?: string | undefined;
+    partial_images?: number | undefined;
+    quality?: string | undefined;
+    size?: string | undefined;
+};
+/** @internal */
+export declare const OpenResponsesImageGenerationTool$outboundSchema: z.ZodType<OpenResponsesImageGenerationTool$Outbound, OpenResponsesImageGenerationTool>;
+export declare function openResponsesImageGenerationToolToJSON(openResponsesImageGenerationTool: OpenResponsesImageGenerationTool): string;
+export declare function openResponsesImageGenerationToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenerationTool, SDKValidationError>;
+//# sourceMappingURL=openresponsesimagegenerationtool.d.ts.map

package/esm/models/openresponsesimagegenerationtool.js

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 149a19208595
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Background = {
+    Transparent: "transparent",
+    Opaque: "opaque",
+    Auto: "auto",
+};
+export const InputFidelity = {
+    High: "high",
+    Low: "low",
+};
+export const ModelEnum = {
+    GptImage1: "gpt-image-1",
+    GptImage1Mini: "gpt-image-1-mini",
+};
+export const Moderation = {
+    Auto: "auto",
+    Low: "low",
+};
+export const OutputFormat = {
+    Png: "png",
+    Webp: "webp",
+    Jpeg: "jpeg",
+};
+export const Quality = {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+    Auto: "auto",
+};
+export const Size = {
+    OneThousandAndTwentyFourx1024: "1024x1024",
+    OneThousandAndTwentyFourx1536: "1024x1536",
+    OneThousandFiveHundredAndThirtySixx1024: "1536x1024",
+    Auto: "auto",
+};
+/** @internal */
+export const Background$inboundSchema = openEnums.inboundSchema(Background);
+/** @internal */
+export const Background$outboundSchema = openEnums.outboundSchema(Background);
+/** @internal */
+export const InputFidelity$inboundSchema = openEnums.inboundSchema(InputFidelity);
+/** @internal */
+export const InputFidelity$outboundSchema = openEnums.outboundSchema(InputFidelity);
+/** @internal */
+export const InputImageMask$inboundSchema = z.object({
+    image_url: z.string().optional(),
+    file_id: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+        "file_id": "fileId",
+    });
+});
+/** @internal */
+export const InputImageMask$outboundSchema = z.object({
+    imageUrl: z.string().optional(),
+    fileId: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+        fileId: "file_id",
+    });
+});
+export function inputImageMaskToJSON(inputImageMask) {
+    return JSON.stringify(InputImageMask$outboundSchema.parse(inputImageMask));
+}
+export function inputImageMaskFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputImageMask$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputImageMask' from JSON`);
+}
+/** @internal */
+export const ModelEnum$inboundSchema = openEnums
+    .inboundSchema(ModelEnum);
+/** @internal */
+export const ModelEnum$outboundSchema = openEnums
+    .outboundSchema(ModelEnum);
+/** @internal */
+export const Moderation$inboundSchema = openEnums.inboundSchema(Moderation);
+/** @internal */
+export const Moderation$outboundSchema = openEnums.outboundSchema(Moderation);
+/** @internal */
+export const OutputFormat$inboundSchema = openEnums.inboundSchema(OutputFormat);
+/** @internal */
+export const OutputFormat$outboundSchema = openEnums.outboundSchema(OutputFormat);
+/** @internal */
+export const Quality$inboundSchema = openEnums
+    .inboundSchema(Quality);
+/** @internal */
+export const Quality$outboundSchema = openEnums
+    .outboundSchema(Quality);
+/** @internal */
+export const Size$inboundSchema = openEnums
+    .inboundSchema(Size);
+/** @internal */
+export const Size$outboundSchema = openEnums
+    .outboundSchema(Size);
+/** @internal */
+export const OpenResponsesImageGenerationTool$inboundSchema = z.object({
+    type: z.literal("image_generation"),
+    background: Background$inboundSchema.optional(),
+    input_fidelity: z.nullable(InputFidelity$inboundSchema).optional(),
+    input_image_mask: z.lazy(() => InputImageMask$inboundSchema).optional(),
+    model: ModelEnum$inboundSchema.optional(),
+    moderation: Moderation$inboundSchema.optional(),
+    output_compression: z.number().optional(),
+    output_format: OutputFormat$inboundSchema.optional(),
+    partial_images: z.number().optional(),
+    quality: Quality$inboundSchema.optional(),
+    size: Size$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "input_fidelity": "inputFidelity",
+        "input_image_mask": "inputImageMask",
+        "output_compression": "outputCompression",
+        "output_format": "outputFormat",
+        "partial_images": "partialImages",
+    });
+});
+/** @internal */
+export const OpenResponsesImageGenerationTool$outboundSchema = z.object({
+    type: z.literal("image_generation"),
+    background: Background$outboundSchema.optional(),
+    inputFidelity: z.nullable(InputFidelity$outboundSchema).optional(),
+    inputImageMask: z.lazy(() => InputImageMask$outboundSchema).optional(),
+    model: ModelEnum$outboundSchema.optional(),
+    moderation: Moderation$outboundSchema.optional(),
+    outputCompression: z.number().optional(),
+    outputFormat: OutputFormat$outboundSchema.optional(),
+    partialImages: z.number().optional(),
+    quality: Quality$outboundSchema.optional(),
+    size: Size$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        inputFidelity: "input_fidelity",
+        inputImageMask: "input_image_mask",
+        outputCompression: "output_compression",
+        outputFormat: "output_format",
+        partialImages: "partial_images",
+    });
+});
+export function openResponsesImageGenerationToolToJSON(openResponsesImageGenerationTool) {
+    return JSON.stringify(OpenResponsesImageGenerationTool$outboundSchema.parse(openResponsesImageGenerationTool));
+}
+export function openResponsesImageGenerationToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesImageGenerationTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenerationTool' from JSON`);
+}
+//# sourceMappingURL=openresponsesimagegenerationtool.js.map

package/esm/models/openresponsesinputmessageitem.d.ts

@@ -40,7 +40,7 @@ export type OpenResponsesInputMessageItem = {
     id?: string | undefined;
     type?: OpenResponsesInputMessageItemTypeMessage | undefined;
     role: OpenResponsesInputMessageItemRoleUser | OpenResponsesInputMessageItemRoleSystem | OpenResponsesInputMessageItemRoleDeveloper;
-    content: Array<ResponseInputText | OpenResponsesInputMessageItemContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo>;
+    content?: Array<ResponseInputText | OpenResponsesInputMessageItemContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo> | null | undefined;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItemTypeMessage$outboundSchema: z.ZodEnum<typeof OpenResponsesInputMessageItemTypeMessage>;
@@ -76,7 +76,7 @@ export type OpenResponsesInputMessageItem$Outbound = {
     id?: string | undefined;
     type?: string | undefined;
     role: string | string | string;
-    content: Array<ResponseInputText$Outbound | OpenResponsesInputMessageItemContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound>;
+    content?: Array<ResponseInputText$Outbound | OpenResponsesInputMessageItemContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound> | null | undefined;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItem$outboundSchema: z.ZodType<OpenResponsesInputMessageItem$Outbound, OpenResponsesInputMessageItem>;

package/esm/models/openresponsesinputmessageitem.js

@@ -78,13 +78,13 @@ export const OpenResponsesInputMessageItem$outboundSchema = z.object({
         OpenResponsesInputMessageItemRoleSystem$outboundSchema,
         OpenResponsesInputMessageItemRoleDeveloper$outboundSchema,
     ]),
-    content: z.array(z.union([
+    content: z.nullable(z.array(z.union([
         ResponseInputText$outboundSchema,
         z.lazy(() => OpenResponsesInputMessageItemContentInputImage$outboundSchema),
         ResponseInputFile$outboundSchema,
         ResponseInputAudio$outboundSchema,
         ResponseInputVideo$outboundSchema,
-    ])),
+    ]))).optional(),
 });
 export function openResponsesInputMessageItemToJSON(openResponsesInputMessageItem) {
     return JSON.stringify(OpenResponsesInputMessageItem$outboundSchema.parse(openResponsesInputMessageItem));

package/esm/models/openresponsesinputunion.d.ts

@@ -0,0 +1,207 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { OpenAIResponsesRefusalContent, OpenAIResponsesRefusalContent$Outbound } from "./openairesponsesrefusalcontent.js";
+import { OpenResponsesEasyInputMessage, OpenResponsesEasyInputMessage$Outbound } from "./openresponseseasyinputmessage.js";
+import { OpenResponsesFunctionCallOutput, OpenResponsesFunctionCallOutput$Outbound } from "./openresponsesfunctioncalloutput.js";
+import { OpenResponsesFunctionToolCall, OpenResponsesFunctionToolCall$Outbound } from "./openresponsesfunctiontoolcall.js";
+import { OpenResponsesInputMessageItem, OpenResponsesInputMessageItem$Outbound } from "./openresponsesinputmessageitem.js";
+import { OpenResponsesReasoning, OpenResponsesReasoning$Outbound } from "./openresponsesreasoning.js";
+import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
+import { ReasoningTextContent, ReasoningTextContent$Outbound } from "./reasoningtextcontent.js";
+import { ResponseOutputText, ResponseOutputText$Outbound } from "./responseoutputtext.js";
+import { ResponsesImageGenerationCall, ResponsesImageGenerationCall$Outbound } from "./responsesimagegenerationcall.js";
+import { ResponsesOutputItemFileSearchCall, ResponsesOutputItemFileSearchCall$Outbound } from "./responsesoutputitemfilesearchcall.js";
+import { ResponsesOutputItemFunctionCall, ResponsesOutputItemFunctionCall$Outbound } from "./responsesoutputitemfunctioncall.js";
+import { ResponsesServerToolOutput, ResponsesServerToolOutput$Outbound } from "./responsesservertooloutput.js";
+import { ResponsesWebSearchCallOutput, ResponsesWebSearchCallOutput$Outbound } from "./responseswebsearchcalloutput.js";
+export declare const OpenResponsesInputTypeReasoning: {
+    readonly Reasoning: "reasoning";
+};
+export type OpenResponsesInputTypeReasoning = ClosedEnum<typeof OpenResponsesInputTypeReasoning>;
+export declare const OpenResponsesInputStatusInProgress2: {
+    readonly InProgress: "in_progress";
+};
+export type OpenResponsesInputStatusInProgress2 = ClosedEnum<typeof OpenResponsesInputStatusInProgress2>;
+export declare const OpenResponsesInputStatusIncomplete2: {
+    readonly Incomplete: "incomplete";
+};
+export type OpenResponsesInputStatusIncomplete2 = ClosedEnum<typeof OpenResponsesInputStatusIncomplete2>;
+export declare const OpenResponsesInputStatusCompleted2: {
+    readonly Completed: "completed";
+};
+export type OpenResponsesInputStatusCompleted2 = ClosedEnum<typeof OpenResponsesInputStatusCompleted2>;
+export type OpenResponsesInputStatusUnion2 = OpenResponsesInputStatusCompleted2 | OpenResponsesInputStatusIncomplete2 | OpenResponsesInputStatusInProgress2;
+/**
+ * The format of the reasoning content
+ */
+export declare const OpenResponsesInputFormat: {
+    readonly Unknown: "unknown";
+    readonly OpenaiResponsesV1: "openai-responses-v1";
+    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
+    readonly XaiResponsesV1: "xai-responses-v1";
+    readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
+};
+/**
+ * The format of the reasoning content
+ */
+export type OpenResponsesInputFormat = OpenEnum<typeof OpenResponsesInputFormat>;
+/**
+ * An output item containing reasoning
+ */
+export type OpenResponsesInputReasoning = {
+    type: OpenResponsesInputTypeReasoning;
+    id: string;
+    content?: Array<ReasoningTextContent> | null | undefined;
+    summary: Array<ReasoningSummaryText> | null;
+    encryptedContent?: string | null | undefined;
+    status?: OpenResponsesInputStatusCompleted2 | OpenResponsesInputStatusIncomplete2 | OpenResponsesInputStatusInProgress2 | undefined;
+    /**
+     * A signature for the reasoning content, used for verification
+     */
+    signature?: string | null | undefined;
+    /**
+     * The format of the reasoning content
+     */
+    format?: OpenResponsesInputFormat | null | undefined;
+};
+export declare const OpenResponsesInputRole: {
+    readonly Assistant: "assistant";
+};
+export type OpenResponsesInputRole = ClosedEnum<typeof OpenResponsesInputRole>;
+export declare const OpenResponsesInputTypeMessage: {
+    readonly Message: "message";
+};
+export type OpenResponsesInputTypeMessage = ClosedEnum<typeof OpenResponsesInputTypeMessage>;
+export declare const OpenResponsesInputStatusInProgress1: {
+    readonly InProgress: "in_progress";
+};
+export type OpenResponsesInputStatusInProgress1 = ClosedEnum<typeof OpenResponsesInputStatusInProgress1>;
+export declare const OpenResponsesInputStatusIncomplete1: {
+    readonly Incomplete: "incomplete";
+};
+export type OpenResponsesInputStatusIncomplete1 = ClosedEnum<typeof OpenResponsesInputStatusIncomplete1>;
+export declare const OpenResponsesInputStatusCompleted1: {
+    readonly Completed: "completed";
+};
+export type OpenResponsesInputStatusCompleted1 = ClosedEnum<typeof OpenResponsesInputStatusCompleted1>;
+export type OpenResponsesInputStatusUnion1 = OpenResponsesInputStatusCompleted1 | OpenResponsesInputStatusIncomplete1 | OpenResponsesInputStatusInProgress1;
+export type OpenResponsesInputContent1 = ResponseOutputText | OpenAIResponsesRefusalContent;
+export type OpenResponsesInputContent2 = Array<ResponseOutputText | OpenAIResponsesRefusalContent> | string | any;
+export declare const OpenResponsesInputPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type OpenResponsesInputPhaseFinalAnswer = ClosedEnum<typeof OpenResponsesInputPhaseFinalAnswer>;
+export declare const OpenResponsesInputPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type OpenResponsesInputPhaseCommentary = ClosedEnum<typeof OpenResponsesInputPhaseCommentary>;
+/**
+ * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+ */
+export type OpenResponsesInputPhaseUnion = OpenResponsesInputPhaseCommentary | OpenResponsesInputPhaseFinalAnswer | any;
+/**
+ * An output message item
+ */
+export type OpenResponsesInputMessage = {
+    id: string;
+    role: OpenResponsesInputRole;
+    type: OpenResponsesInputTypeMessage;
+    status?: OpenResponsesInputStatusCompleted1 | OpenResponsesInputStatusIncomplete1 | OpenResponsesInputStatusInProgress1 | undefined;
+    content?: Array<ResponseOutputText | OpenAIResponsesRefusalContent> | string | any | null | undefined;
+    /**
+     * The phase of an assistant message. Use `commentary` for an intermediate assistant message and `final_answer` for the final assistant message. For follow-up requests with models like `gpt-5.3-codex` and later, preserve and resend phase on all assistant messages. Omitting it can degrade performance. Not used for user messages.
+     */
+    phase?: OpenResponsesInputPhaseCommentary | OpenResponsesInputPhaseFinalAnswer | any | null | undefined;
+};
+export type OpenResponsesInputUnion1 = OpenResponsesFunctionToolCall | OpenResponsesInputMessage | ResponsesOutputItemFunctionCall | ResponsesWebSearchCallOutput | ResponsesOutputItemFileSearchCall | OpenResponsesReasoning | OpenResponsesFunctionCallOutput | OpenResponsesInputReasoning | ResponsesImageGenerationCall | ResponsesServerToolOutput | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem;
+/**
+ * Input for a response request - can be a string or array of items
+ */
+export type OpenResponsesInputUnion = string | Array<OpenResponsesFunctionToolCall | OpenResponsesInputMessage | ResponsesOutputItemFunctionCall | ResponsesWebSearchCallOutput | ResponsesOutputItemFileSearchCall | OpenResponsesReasoning | OpenResponsesFunctionCallOutput | OpenResponsesInputReasoning | ResponsesImageGenerationCall | ResponsesServerToolOutput | OpenResponsesEasyInputMessage | OpenResponsesInputMessageItem>;
+/** @internal */
+export declare const OpenResponsesInputTypeReasoning$outboundSchema: z.ZodEnum<typeof OpenResponsesInputTypeReasoning>;
+/** @internal */
+export declare const OpenResponsesInputStatusInProgress2$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusInProgress2>;
+/** @internal */
+export declare const OpenResponsesInputStatusIncomplete2$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusIncomplete2>;
+/** @internal */
+export declare const OpenResponsesInputStatusCompleted2$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusCompleted2>;
+/** @internal */
+export type OpenResponsesInputStatusUnion2$Outbound = string | string | string;
+/** @internal */
+export declare const OpenResponsesInputStatusUnion2$outboundSchema: z.ZodType<OpenResponsesInputStatusUnion2$Outbound, OpenResponsesInputStatusUnion2>;
+export declare function openResponsesInputStatusUnion2ToJSON(openResponsesInputStatusUnion2: OpenResponsesInputStatusUnion2): string;
+/** @internal */
+export declare const OpenResponsesInputFormat$outboundSchema: z.ZodType<string, OpenResponsesInputFormat>;
+/** @internal */
+export type OpenResponsesInputReasoning$Outbound = {
+    type: string;
+    id: string;
+    content?: Array<ReasoningTextContent$Outbound> | null | undefined;
+    summary: Array<ReasoningSummaryText$Outbound> | null;
+    encrypted_content?: string | null | undefined;
+    status?: string | string | string | undefined;
+    signature?: string | null | undefined;
+    format?: string | null | undefined;
+};
+/** @internal */
+export declare const OpenResponsesInputReasoning$outboundSchema: z.ZodType<OpenResponsesInputReasoning$Outbound, OpenResponsesInputReasoning>;
+export declare function openResponsesInputReasoningToJSON(openResponsesInputReasoning: OpenResponsesInputReasoning): string;
+/** @internal */
+export declare const OpenResponsesInputRole$outboundSchema: z.ZodEnum<typeof OpenResponsesInputRole>;
+/** @internal */
+export declare const OpenResponsesInputTypeMessage$outboundSchema: z.ZodEnum<typeof OpenResponsesInputTypeMessage>;
+/** @internal */
+export declare const OpenResponsesInputStatusInProgress1$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusInProgress1>;
+/** @internal */
+export declare const OpenResponsesInputStatusIncomplete1$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusIncomplete1>;
+/** @internal */
+export declare const OpenResponsesInputStatusCompleted1$outboundSchema: z.ZodEnum<typeof OpenResponsesInputStatusCompleted1>;
+/** @internal */
+export type OpenResponsesInputStatusUnion1$Outbound = string | string | string;
+/** @internal */
+export declare const OpenResponsesInputStatusUnion1$outboundSchema: z.ZodType<OpenResponsesInputStatusUnion1$Outbound, OpenResponsesInputStatusUnion1>;
+export declare function openResponsesInputStatusUnion1ToJSON(openResponsesInputStatusUnion1: OpenResponsesInputStatusUnion1): string;
+/** @internal */
+export type OpenResponsesInputContent1$Outbound = ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound;
+/** @internal */
+export declare const OpenResponsesInputContent1$outboundSchema: z.ZodType<OpenResponsesInputContent1$Outbound, OpenResponsesInputContent1>;
+export declare function openResponsesInputContent1ToJSON(openResponsesInputContent1: OpenResponsesInputContent1): string;
+/** @internal */
+export type OpenResponsesInputContent2$Outbound = Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound> | string | any;
+/** @internal */
+export declare const OpenResponsesInputContent2$outboundSchema: z.ZodType<OpenResponsesInputContent2$Outbound, OpenResponsesInputContent2>;
+export declare function openResponsesInputContent2ToJSON(openResponsesInputContent2: OpenResponsesInputContent2): string;
+/** @internal */
+export declare const OpenResponsesInputPhaseFinalAnswer$outboundSchema: z.ZodEnum<typeof OpenResponsesInputPhaseFinalAnswer>;
+/** @internal */
+export declare const OpenResponsesInputPhaseCommentary$outboundSchema: z.ZodEnum<typeof OpenResponsesInputPhaseCommentary>;
+/** @internal */
+export type OpenResponsesInputPhaseUnion$Outbound = string | string | any;
+/** @internal */
+export declare const OpenResponsesInputPhaseUnion$outboundSchema: z.ZodType<OpenResponsesInputPhaseUnion$Outbound, OpenResponsesInputPhaseUnion>;
+export declare function openResponsesInputPhaseUnionToJSON(openResponsesInputPhaseUnion: OpenResponsesInputPhaseUnion): string;
+/** @internal */
+export type OpenResponsesInputMessage$Outbound = {
+    id: string;
+    role: string;
+    type: string;
+    status?: string | string | string | undefined;
+    content?: Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound> | string | any | null | undefined;
+    phase?: string | string | any | null | undefined;
+};
+/** @internal */
+export declare const OpenResponsesInputMessage$outboundSchema: z.ZodType<OpenResponsesInputMessage$Outbound, OpenResponsesInputMessage>;
+export declare function openResponsesInputMessageToJSON(openResponsesInputMessage: OpenResponsesInputMessage): string;
+/** @internal */
+export type OpenResponsesInputUnion1$Outbound = OpenResponsesFunctionToolCall$Outbound | OpenResponsesInputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesWebSearchCallOutput$Outbound | ResponsesOutputItemFileSearchCall$Outbound | OpenResponsesReasoning$Outbound | OpenResponsesFunctionCallOutput$Outbound | OpenResponsesInputReasoning$Outbound | ResponsesImageGenerationCall$Outbound | ResponsesServerToolOutput$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound;
+/** @internal */
+export declare const OpenResponsesInputUnion1$outboundSchema: z.ZodType<OpenResponsesInputUnion1$Outbound, OpenResponsesInputUnion1>;
+export declare function openResponsesInputUnion1ToJSON(openResponsesInputUnion1: OpenResponsesInputUnion1): string;
+/** @internal */
+export type OpenResponsesInputUnion$Outbound = string | Array<OpenResponsesFunctionToolCall$Outbound | OpenResponsesInputMessage$Outbound | ResponsesOutputItemFunctionCall$Outbound | ResponsesWebSearchCallOutput$Outbound | ResponsesOutputItemFileSearchCall$Outbound | OpenResponsesReasoning$Outbound | OpenResponsesFunctionCallOutput$Outbound | OpenResponsesInputReasoning$Outbound | ResponsesImageGenerationCall$Outbound | ResponsesServerToolOutput$Outbound | OpenResponsesEasyInputMessage$Outbound | OpenResponsesInputMessageItem$Outbound>;
+/** @internal */
+export declare const OpenResponsesInputUnion$outboundSchema: z.ZodType<OpenResponsesInputUnion$Outbound, OpenResponsesInputUnion>;
+export declare function openResponsesInputUnionToJSON(openResponsesInputUnion: OpenResponsesInputUnion): string;
+//# sourceMappingURL=openresponsesinputunion.d.ts.map