@openrouter/sdk 0.10.2 → 0.11.2

package/esm/models/inputaudio.js

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9bdc14c7565f
+ */
+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 InputAudioFormat = {
+    Mp3: "mp3",
+    Wav: "wav",
+};
+/** @internal */
+export const InputAudioFormat$inboundSchema = openEnums.inboundSchema(InputAudioFormat);
+/** @internal */
+export const InputAudioFormat$outboundSchema = openEnums.outboundSchema(InputAudioFormat);
+/** @internal */
+export const InputAudioInputAudio$inboundSchema = z.object({
+    data: z.string(),
+    format: InputAudioFormat$inboundSchema,
+});
+/** @internal */
+export const InputAudioInputAudio$outboundSchema = z.object({
+    data: z.string(),
+    format: InputAudioFormat$outboundSchema,
+});
+export function inputAudioInputAudioToJSON(inputAudioInputAudio) {
+    return JSON.stringify(InputAudioInputAudio$outboundSchema.parse(inputAudioInputAudio));
+}
+export function inputAudioInputAudioFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputAudioInputAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputAudioInputAudio' from JSON`);
+}
+/** @internal */
+export const InputAudio$inboundSchema = z
+    .object({
+    type: z.literal("input_audio"),
+    input_audio: z.lazy(() => InputAudioInputAudio$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "input_audio": "inputAudio",
+    });
+});
+/** @internal */
+export const InputAudio$outboundSchema = z.object({
+    type: z.literal("input_audio"),
+    inputAudio: z.lazy(() => InputAudioInputAudio$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        inputAudio: "input_audio",
+    });
+});
+export function inputAudioToJSON(inputAudio) {
+    return JSON.stringify(InputAudio$outboundSchema.parse(inputAudio));
+}
+export function inputAudioFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputAudio' from JSON`);
+}
+//# sourceMappingURL=inputaudio.js.map

package/esm/models/{responseinputfile.d.ts → inputfile.d.ts}

@@ -4,7 +4,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * File input content item
  */
-export type ResponseInputFile = {
+export type InputFile = {
     type: "input_file";
     fileId?: string | null | undefined;
     fileData?: string | undefined;
@@ -12,9 +12,9 @@ export type ResponseInputFile = {
     fileUrl?: string | undefined;
 };
 /** @internal */
-export declare const ResponseInputFile$inboundSchema: z.ZodType<ResponseInputFile, unknown>;
+export declare const InputFile$inboundSchema: z.ZodType<InputFile, unknown>;
 /** @internal */
-export type ResponseInputFile$Outbound = {
+export type InputFile$Outbound = {
     type: "input_file";
     file_id?: string | null | undefined;
     file_data?: string | undefined;
@@ -22,7 +22,7 @@ export type ResponseInputFile$Outbound = {
     file_url?: string | undefined;
 };
 /** @internal */
-export declare const ResponseInputFile$outboundSchema: z.ZodType<ResponseInputFile$Outbound, ResponseInputFile>;
-export declare function responseInputFileToJSON(responseInputFile: ResponseInputFile): string;
-export declare function responseInputFileFromJSON(jsonString: string): SafeParseResult<ResponseInputFile, SDKValidationError>;
-//# sourceMappingURL=responseinputfile.d.ts.map
+export declare const InputFile$outboundSchema: z.ZodType<InputFile$Outbound, InputFile>;
+export declare function inputFileToJSON(inputFile: InputFile): string;
+export declare function inputFileFromJSON(jsonString: string): SafeParseResult<InputFile, SDKValidationError>;
+//# sourceMappingURL=inputfile.d.ts.map

package/esm/models/{responseinputfile.js → inputfile.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: f449677cc221
+ * @generated-id: 21319fb604ac
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const ResponseInputFile$inboundSchema = z.object({
+export const InputFile$inboundSchema = z.object({
     type: z.literal("input_file"),
     file_id: z.nullable(z.string()).optional(),
     file_data: z.string().optional(),
@@ -20,7 +20,7 @@ export const ResponseInputFile$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const ResponseInputFile$outboundSchema = z.object({
+export const InputFile$outboundSchema = z.object({
     type: z.literal("input_file"),
     fileId: z.nullable(z.string()).optional(),
     fileData: z.string().optional(),
@@ -33,10 +33,10 @@ export const ResponseInputFile$outboundSchema = z.object({
         fileUrl: "file_url",
     });
 });
-export function responseInputFileToJSON(responseInputFile) {
-    return JSON.stringify(ResponseInputFile$outboundSchema.parse(responseInputFile));
+export function inputFileToJSON(inputFile) {
+    return JSON.stringify(InputFile$outboundSchema.parse(inputFile));
 }
-export function responseInputFileFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ResponseInputFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponseInputFile' from JSON`);
+export function inputFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputFile' from JSON`);
 }
-//# sourceMappingURL=responseinputfile.js.map
+//# sourceMappingURL=inputfile.js.map

package/esm/models/inputimage.d.ts

@@ -0,0 +1,43 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const InputImageTypeEnum: {
+    readonly InputImage: "input_image";
+};
+export type InputImageTypeEnum = ClosedEnum<typeof InputImageTypeEnum>;
+export declare const InputImageDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type InputImageDetail = OpenEnum<typeof InputImageDetail>;
+/**
+ * Image input content item
+ */
+export type InputImage = {
+    type: InputImageTypeEnum;
+    detail: InputImageDetail;
+    imageUrl?: string | null | undefined;
+};
+/** @internal */
+export declare const InputImageTypeEnum$inboundSchema: z.ZodEnum<typeof InputImageTypeEnum>;
+/** @internal */
+export declare const InputImageTypeEnum$outboundSchema: z.ZodEnum<typeof InputImageTypeEnum>;
+/** @internal */
+export declare const InputImageDetail$inboundSchema: z.ZodType<InputImageDetail, unknown>;
+/** @internal */
+export declare const InputImageDetail$outboundSchema: z.ZodType<string, InputImageDetail>;
+/** @internal */
+export declare const InputImage$inboundSchema: z.ZodType<InputImage, unknown>;
+/** @internal */
+export type InputImage$Outbound = {
+    type: string;
+    detail: string;
+    image_url?: string | null | undefined;
+};
+/** @internal */
+export declare const InputImage$outboundSchema: z.ZodType<InputImage$Outbound, InputImage>;
+export declare function inputImageToJSON(inputImage: InputImage): string;
+export declare function inputImageFromJSON(jsonString: string): SafeParseResult<InputImage, SDKValidationError>;
+//# sourceMappingURL=inputimage.d.ts.map

package/esm/models/inputimage.js

@@ -0,0 +1,52 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7a718177a217
+ */
+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 InputImageTypeEnum = {
+    InputImage: "input_image",
+};
+export const InputImageDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+/** @internal */
+export const InputImageTypeEnum$inboundSchema = z.enum(InputImageTypeEnum);
+/** @internal */
+export const InputImageTypeEnum$outboundSchema = InputImageTypeEnum$inboundSchema;
+/** @internal */
+export const InputImageDetail$inboundSchema = openEnums.inboundSchema(InputImageDetail);
+/** @internal */
+export const InputImageDetail$outboundSchema = openEnums.outboundSchema(InputImageDetail);
+/** @internal */
+export const InputImage$inboundSchema = z
+    .object({
+    type: InputImageTypeEnum$inboundSchema,
+    detail: InputImageDetail$inboundSchema,
+    image_url: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const InputImage$outboundSchema = z.object({
+    type: InputImageTypeEnum$outboundSchema,
+    detail: InputImageDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function inputImageToJSON(inputImage) {
+    return JSON.stringify(InputImage$outboundSchema.parse(inputImage));
+}
+export function inputImageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputImage' from JSON`);
+}
+//# sourceMappingURL=inputimage.js.map

package/esm/models/inputmessageitem.d.ts

@@ -0,0 +1,84 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { InputAudio, InputAudio$Outbound } from "./inputaudio.js";
+import { InputFile, InputFile$Outbound } from "./inputfile.js";
+import { InputText, InputText$Outbound } from "./inputtext.js";
+import { InputVideo, InputVideo$Outbound } from "./inputvideo.js";
+export declare const InputMessageItemTypeMessage: {
+    readonly Message: "message";
+};
+export type InputMessageItemTypeMessage = ClosedEnum<typeof InputMessageItemTypeMessage>;
+export declare const InputMessageItemRoleDeveloper: {
+    readonly Developer: "developer";
+};
+export type InputMessageItemRoleDeveloper = ClosedEnum<typeof InputMessageItemRoleDeveloper>;
+export declare const InputMessageItemRoleSystem: {
+    readonly System: "system";
+};
+export type InputMessageItemRoleSystem = ClosedEnum<typeof InputMessageItemRoleSystem>;
+export declare const InputMessageItemRoleUser: {
+    readonly User: "user";
+};
+export type InputMessageItemRoleUser = ClosedEnum<typeof InputMessageItemRoleUser>;
+export type InputMessageItemRoleUnion = InputMessageItemRoleUser | InputMessageItemRoleSystem | InputMessageItemRoleDeveloper;
+export declare const InputMessageItemDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type InputMessageItemDetail = OpenEnum<typeof InputMessageItemDetail>;
+/**
+ * Image input content item
+ */
+export type InputMessageItemContentInputImage = {
+    type: "input_image";
+    detail: InputMessageItemDetail;
+    imageUrl?: string | null | undefined;
+};
+export type InputMessageItemContentUnion = InputText | InputMessageItemContentInputImage | InputFile | InputAudio | InputVideo;
+export type InputMessageItem = {
+    id?: string | undefined;
+    type?: InputMessageItemTypeMessage | undefined;
+    role: InputMessageItemRoleUser | InputMessageItemRoleSystem | InputMessageItemRoleDeveloper;
+    content?: Array<InputText | InputMessageItemContentInputImage | InputFile | InputAudio | InputVideo> | null | undefined;
+};
+/** @internal */
+export declare const InputMessageItemTypeMessage$outboundSchema: z.ZodEnum<typeof InputMessageItemTypeMessage>;
+/** @internal */
+export declare const InputMessageItemRoleDeveloper$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleDeveloper>;
+/** @internal */
+export declare const InputMessageItemRoleSystem$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleSystem>;
+/** @internal */
+export declare const InputMessageItemRoleUser$outboundSchema: z.ZodEnum<typeof InputMessageItemRoleUser>;
+/** @internal */
+export type InputMessageItemRoleUnion$Outbound = string | string | string;
+/** @internal */
+export declare const InputMessageItemRoleUnion$outboundSchema: z.ZodType<InputMessageItemRoleUnion$Outbound, InputMessageItemRoleUnion>;
+export declare function inputMessageItemRoleUnionToJSON(inputMessageItemRoleUnion: InputMessageItemRoleUnion): string;
+/** @internal */
+export declare const InputMessageItemDetail$outboundSchema: z.ZodType<string, InputMessageItemDetail>;
+/** @internal */
+export type InputMessageItemContentInputImage$Outbound = {
+    type: "input_image";
+    detail: string;
+    image_url?: string | null | undefined;
+};
+/** @internal */
+export declare const InputMessageItemContentInputImage$outboundSchema: z.ZodType<InputMessageItemContentInputImage$Outbound, InputMessageItemContentInputImage>;
+export declare function inputMessageItemContentInputImageToJSON(inputMessageItemContentInputImage: InputMessageItemContentInputImage): string;
+/** @internal */
+export type InputMessageItemContentUnion$Outbound = InputText$Outbound | InputMessageItemContentInputImage$Outbound | InputFile$Outbound | InputAudio$Outbound | InputVideo$Outbound;
+/** @internal */
+export declare const InputMessageItemContentUnion$outboundSchema: z.ZodType<InputMessageItemContentUnion$Outbound, InputMessageItemContentUnion>;
+export declare function inputMessageItemContentUnionToJSON(inputMessageItemContentUnion: InputMessageItemContentUnion): string;
+/** @internal */
+export type InputMessageItem$Outbound = {
+    id?: string | undefined;
+    type?: string | undefined;
+    role: string | string | string;
+    content?: Array<InputText$Outbound | InputMessageItemContentInputImage$Outbound | InputFile$Outbound | InputAudio$Outbound | InputVideo$Outbound> | null | undefined;
+};
+/** @internal */
+export declare const InputMessageItem$outboundSchema: z.ZodType<InputMessageItem$Outbound, InputMessageItem>;
+export declare function inputMessageItemToJSON(inputMessageItem: InputMessageItem): string;
+//# sourceMappingURL=inputmessageitem.d.ts.map

package/esm/models/inputmessageitem.js

@@ -0,0 +1,92 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 78f212025019
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { InputAudio$outboundSchema, } from "./inputaudio.js";
+import { InputFile$outboundSchema, } from "./inputfile.js";
+import { InputText$outboundSchema, } from "./inputtext.js";
+import { InputVideo$outboundSchema, } from "./inputvideo.js";
+export const InputMessageItemTypeMessage = {
+    Message: "message",
+};
+export const InputMessageItemRoleDeveloper = {
+    Developer: "developer",
+};
+export const InputMessageItemRoleSystem = {
+    System: "system",
+};
+export const InputMessageItemRoleUser = {
+    User: "user",
+};
+export const InputMessageItemDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+/** @internal */
+export const InputMessageItemTypeMessage$outboundSchema = z.enum(InputMessageItemTypeMessage);
+/** @internal */
+export const InputMessageItemRoleDeveloper$outboundSchema = z.enum(InputMessageItemRoleDeveloper);
+/** @internal */
+export const InputMessageItemRoleSystem$outboundSchema = z.enum(InputMessageItemRoleSystem);
+/** @internal */
+export const InputMessageItemRoleUser$outboundSchema = z.enum(InputMessageItemRoleUser);
+/** @internal */
+export const InputMessageItemRoleUnion$outboundSchema = z.union([
+    InputMessageItemRoleUser$outboundSchema,
+    InputMessageItemRoleSystem$outboundSchema,
+    InputMessageItemRoleDeveloper$outboundSchema,
+]);
+export function inputMessageItemRoleUnionToJSON(inputMessageItemRoleUnion) {
+    return JSON.stringify(InputMessageItemRoleUnion$outboundSchema.parse(inputMessageItemRoleUnion));
+}
+/** @internal */
+export const InputMessageItemDetail$outboundSchema = openEnums.outboundSchema(InputMessageItemDetail);
+/** @internal */
+export const InputMessageItemContentInputImage$outboundSchema = z.object({
+    type: z.literal("input_image"),
+    detail: InputMessageItemDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function inputMessageItemContentInputImageToJSON(inputMessageItemContentInputImage) {
+    return JSON.stringify(InputMessageItemContentInputImage$outboundSchema.parse(inputMessageItemContentInputImage));
+}
+/** @internal */
+export const InputMessageItemContentUnion$outboundSchema = z.union([
+    InputText$outboundSchema,
+    z.lazy(() => InputMessageItemContentInputImage$outboundSchema),
+    InputFile$outboundSchema,
+    InputAudio$outboundSchema,
+    InputVideo$outboundSchema,
+]);
+export function inputMessageItemContentUnionToJSON(inputMessageItemContentUnion) {
+    return JSON.stringify(InputMessageItemContentUnion$outboundSchema.parse(inputMessageItemContentUnion));
+}
+/** @internal */
+export const InputMessageItem$outboundSchema = z.object({
+    id: z.string().optional(),
+    type: InputMessageItemTypeMessage$outboundSchema.optional(),
+    role: z.union([
+        InputMessageItemRoleUser$outboundSchema,
+        InputMessageItemRoleSystem$outboundSchema,
+        InputMessageItemRoleDeveloper$outboundSchema,
+    ]),
+    content: z.nullable(z.array(z.union([
+        InputText$outboundSchema,
+        z.lazy(() => InputMessageItemContentInputImage$outboundSchema),
+        InputFile$outboundSchema,
+        InputAudio$outboundSchema,
+        InputVideo$outboundSchema,
+    ]))).optional(),
+});
+export function inputMessageItemToJSON(inputMessageItem) {
+    return JSON.stringify(InputMessageItem$outboundSchema.parse(inputMessageItem));
+}
+//# sourceMappingURL=inputmessageitem.js.map

package/esm/models/inputsunion.d.ts

@@ -0,0 +1,208 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { EasyInputMessage, EasyInputMessage$Outbound } from "./easyinputmessage.js";
+import { FunctionCallItem, FunctionCallItem$Outbound } from "./functioncallitem.js";
+import { FunctionCallOutputItem, FunctionCallOutputItem$Outbound } from "./functioncalloutputitem.js";
+import { InputMessageItem, InputMessageItem$Outbound } from "./inputmessageitem.js";
+import { OpenAIResponsesRefusalContent, OpenAIResponsesRefusalContent$Outbound } from "./openairesponsesrefusalcontent.js";
+import { OutputDatetimeItem, OutputDatetimeItem$Outbound } from "./outputdatetimeitem.js";
+import { OutputFileSearchCallItem, OutputFileSearchCallItem$Outbound } from "./outputfilesearchcallitem.js";
+import { OutputFunctionCallItem, OutputFunctionCallItem$Outbound } from "./outputfunctioncallitem.js";
+import { OutputImageGenerationCallItem, OutputImageGenerationCallItem$Outbound } from "./outputimagegenerationcallitem.js";
+import { OutputServerToolItem, OutputServerToolItem$Outbound } from "./outputservertoolitem.js";
+import { OutputWebSearchCallItem, OutputWebSearchCallItem$Outbound } from "./outputwebsearchcallitem.js";
+import { ReasoningItem, ReasoningItem$Outbound } from "./reasoningitem.js";
+import { ReasoningSummaryText, ReasoningSummaryText$Outbound } from "./reasoningsummarytext.js";
+import { ReasoningTextContent, ReasoningTextContent$Outbound } from "./reasoningtextcontent.js";
+import { ResponseOutputText, ResponseOutputText$Outbound } from "./responseoutputtext.js";
+export declare const InputsTypeReasoning: {
+    readonly Reasoning: "reasoning";
+};
+export type InputsTypeReasoning = ClosedEnum<typeof InputsTypeReasoning>;
+export declare const InputsStatusInProgress2: {
+    readonly InProgress: "in_progress";
+};
+export type InputsStatusInProgress2 = ClosedEnum<typeof InputsStatusInProgress2>;
+export declare const InputsStatusIncomplete2: {
+    readonly Incomplete: "incomplete";
+};
+export type InputsStatusIncomplete2 = ClosedEnum<typeof InputsStatusIncomplete2>;
+export declare const InputsStatusCompleted2: {
+    readonly Completed: "completed";
+};
+export type InputsStatusCompleted2 = ClosedEnum<typeof InputsStatusCompleted2>;
+export type InputsStatusUnion2 = InputsStatusCompleted2 | InputsStatusIncomplete2 | InputsStatusInProgress2;
+/**
+ * The format of the reasoning content
+ */
+export declare const InputsFormat: {
+    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 InputsFormat = OpenEnum<typeof InputsFormat>;
+/**
+ * An output item containing reasoning
+ */
+export type InputsReasoning = {
+    type: InputsTypeReasoning;
+    id: string;
+    content?: Array<ReasoningTextContent> | null | undefined;
+    summary: Array<ReasoningSummaryText> | null;
+    encryptedContent?: string | null | undefined;
+    status?: InputsStatusCompleted2 | InputsStatusIncomplete2 | InputsStatusInProgress2 | undefined;
+    /**
+     * A signature for the reasoning content, used for verification
+     */
+    signature?: string | null | undefined;
+    /**
+     * The format of the reasoning content
+     */
+    format?: InputsFormat | null | undefined;
+};
+export declare const InputsRole: {
+    readonly Assistant: "assistant";
+};
+export type InputsRole = ClosedEnum<typeof InputsRole>;
+export declare const InputsTypeMessage: {
+    readonly Message: "message";
+};
+export type InputsTypeMessage = ClosedEnum<typeof InputsTypeMessage>;
+export declare const InputsStatusInProgress1: {
+    readonly InProgress: "in_progress";
+};
+export type InputsStatusInProgress1 = ClosedEnum<typeof InputsStatusInProgress1>;
+export declare const InputsStatusIncomplete1: {
+    readonly Incomplete: "incomplete";
+};
+export type InputsStatusIncomplete1 = ClosedEnum<typeof InputsStatusIncomplete1>;
+export declare const InputsStatusCompleted1: {
+    readonly Completed: "completed";
+};
+export type InputsStatusCompleted1 = ClosedEnum<typeof InputsStatusCompleted1>;
+export type InputsStatusUnion1 = InputsStatusCompleted1 | InputsStatusIncomplete1 | InputsStatusInProgress1;
+export type InputsContent1 = ResponseOutputText | OpenAIResponsesRefusalContent;
+export type InputsContent2 = Array<ResponseOutputText | OpenAIResponsesRefusalContent> | string | any;
+export declare const InputsPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type InputsPhaseFinalAnswer = ClosedEnum<typeof InputsPhaseFinalAnswer>;
+export declare const InputsPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type InputsPhaseCommentary = ClosedEnum<typeof InputsPhaseCommentary>;
+/**
+ * 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 InputsPhaseUnion = InputsPhaseCommentary | InputsPhaseFinalAnswer | any;
+/**
+ * An output message item
+ */
+export type InputsMessage = {
+    id: string;
+    role: InputsRole;
+    type: InputsTypeMessage;
+    status?: InputsStatusCompleted1 | InputsStatusIncomplete1 | InputsStatusInProgress1 | undefined;
+    content: Array<ResponseOutputText | OpenAIResponsesRefusalContent> | string | any | null;
+    /**
+     * 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?: InputsPhaseCommentary | InputsPhaseFinalAnswer | any | null | undefined;
+};
+export type InputsUnion1 = FunctionCallItem | InputsMessage | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputDatetimeItem | ReasoningItem | FunctionCallOutputItem | InputsReasoning | OutputImageGenerationCallItem | OutputServerToolItem | EasyInputMessage | InputMessageItem;
+/**
+ * Input for a response request - can be a string or array of items
+ */
+export type InputsUnion = string | Array<FunctionCallItem | InputsMessage | OutputFunctionCallItem | OutputWebSearchCallItem | OutputFileSearchCallItem | OutputDatetimeItem | ReasoningItem | FunctionCallOutputItem | InputsReasoning | OutputImageGenerationCallItem | OutputServerToolItem | EasyInputMessage | InputMessageItem>;
+/** @internal */
+export declare const InputsTypeReasoning$outboundSchema: z.ZodEnum<typeof InputsTypeReasoning>;
+/** @internal */
+export declare const InputsStatusInProgress2$outboundSchema: z.ZodEnum<typeof InputsStatusInProgress2>;
+/** @internal */
+export declare const InputsStatusIncomplete2$outboundSchema: z.ZodEnum<typeof InputsStatusIncomplete2>;
+/** @internal */
+export declare const InputsStatusCompleted2$outboundSchema: z.ZodEnum<typeof InputsStatusCompleted2>;
+/** @internal */
+export type InputsStatusUnion2$Outbound = string | string | string;
+/** @internal */
+export declare const InputsStatusUnion2$outboundSchema: z.ZodType<InputsStatusUnion2$Outbound, InputsStatusUnion2>;
+export declare function inputsStatusUnion2ToJSON(inputsStatusUnion2: InputsStatusUnion2): string;
+/** @internal */
+export declare const InputsFormat$outboundSchema: z.ZodType<string, InputsFormat>;
+/** @internal */
+export type InputsReasoning$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 InputsReasoning$outboundSchema: z.ZodType<InputsReasoning$Outbound, InputsReasoning>;
+export declare function inputsReasoningToJSON(inputsReasoning: InputsReasoning): string;
+/** @internal */
+export declare const InputsRole$outboundSchema: z.ZodEnum<typeof InputsRole>;
+/** @internal */
+export declare const InputsTypeMessage$outboundSchema: z.ZodEnum<typeof InputsTypeMessage>;
+/** @internal */
+export declare const InputsStatusInProgress1$outboundSchema: z.ZodEnum<typeof InputsStatusInProgress1>;
+/** @internal */
+export declare const InputsStatusIncomplete1$outboundSchema: z.ZodEnum<typeof InputsStatusIncomplete1>;
+/** @internal */
+export declare const InputsStatusCompleted1$outboundSchema: z.ZodEnum<typeof InputsStatusCompleted1>;
+/** @internal */
+export type InputsStatusUnion1$Outbound = string | string | string;
+/** @internal */
+export declare const InputsStatusUnion1$outboundSchema: z.ZodType<InputsStatusUnion1$Outbound, InputsStatusUnion1>;
+export declare function inputsStatusUnion1ToJSON(inputsStatusUnion1: InputsStatusUnion1): string;
+/** @internal */
+export type InputsContent1$Outbound = ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound;
+/** @internal */
+export declare const InputsContent1$outboundSchema: z.ZodType<InputsContent1$Outbound, InputsContent1>;
+export declare function inputsContent1ToJSON(inputsContent1: InputsContent1): string;
+/** @internal */
+export type InputsContent2$Outbound = Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound> | string | any;
+/** @internal */
+export declare const InputsContent2$outboundSchema: z.ZodType<InputsContent2$Outbound, InputsContent2>;
+export declare function inputsContent2ToJSON(inputsContent2: InputsContent2): string;
+/** @internal */
+export declare const InputsPhaseFinalAnswer$outboundSchema: z.ZodEnum<typeof InputsPhaseFinalAnswer>;
+/** @internal */
+export declare const InputsPhaseCommentary$outboundSchema: z.ZodEnum<typeof InputsPhaseCommentary>;
+/** @internal */
+export type InputsPhaseUnion$Outbound = string | string | any;
+/** @internal */
+export declare const InputsPhaseUnion$outboundSchema: z.ZodType<InputsPhaseUnion$Outbound, InputsPhaseUnion>;
+export declare function inputsPhaseUnionToJSON(inputsPhaseUnion: InputsPhaseUnion): string;
+/** @internal */
+export type InputsMessage$Outbound = {
+    id: string;
+    role: string;
+    type: string;
+    status?: string | string | string | undefined;
+    content: Array<ResponseOutputText$Outbound | OpenAIResponsesRefusalContent$Outbound> | string | any | null;
+    phase?: string | string | any | null | undefined;
+};
+/** @internal */
+export declare const InputsMessage$outboundSchema: z.ZodType<InputsMessage$Outbound, InputsMessage>;
+export declare function inputsMessageToJSON(inputsMessage: InputsMessage): string;
+/** @internal */
+export type InputsUnion1$Outbound = FunctionCallItem$Outbound | InputsMessage$Outbound | OutputFunctionCallItem$Outbound | OutputWebSearchCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputDatetimeItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | InputsReasoning$Outbound | OutputImageGenerationCallItem$Outbound | OutputServerToolItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound;
+/** @internal */
+export declare const InputsUnion1$outboundSchema: z.ZodType<InputsUnion1$Outbound, InputsUnion1>;
+export declare function inputsUnion1ToJSON(inputsUnion1: InputsUnion1): string;
+/** @internal */
+export type InputsUnion$Outbound = string | Array<FunctionCallItem$Outbound | InputsMessage$Outbound | OutputFunctionCallItem$Outbound | OutputWebSearchCallItem$Outbound | OutputFileSearchCallItem$Outbound | OutputDatetimeItem$Outbound | ReasoningItem$Outbound | FunctionCallOutputItem$Outbound | InputsReasoning$Outbound | OutputImageGenerationCallItem$Outbound | OutputServerToolItem$Outbound | EasyInputMessage$Outbound | InputMessageItem$Outbound>;
+/** @internal */
+export declare const InputsUnion$outboundSchema: z.ZodType<InputsUnion$Outbound, InputsUnion>;
+export declare function inputsUnionToJSON(inputsUnion: InputsUnion): string;
+//# sourceMappingURL=inputsunion.d.ts.map