@openrouter/sdk 0.0.1-beta.8 → 0.0.1

package/esm/models/openresponseseasyinputmessage.js

@@ -3,7 +3,9 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { OpenResponsesInputContent$inboundSchema, OpenResponsesInputContent$outboundSchema, } from "./openresponsesinputcontent.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";
 export const OpenResponsesEasyInputMessageType = {
     Message: "message",
 };
@@ -126,25 +128,92 @@ export function openResponsesEasyInputMessageRoleUnionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OpenResponsesEasyInputMessageRoleUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesEasyInputMessageRoleUnion' from JSON`);
 }
 /** @internal */
-export const OpenResponsesEasyInputMessageContent$inboundSchema = z.union([z.array(OpenResponsesInputContent$inboundSchema), z.string()]);
+export const OpenResponsesEasyInputMessageContent1$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 OpenResponsesEasyInputMessageContent1$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 OpenResponsesEasyInputMessageContent1$;
+(function (OpenResponsesEasyInputMessageContent1$) {
+    /** @deprecated use `OpenResponsesEasyInputMessageContent1$inboundSchema` instead. */
+    OpenResponsesEasyInputMessageContent1$.inboundSchema = OpenResponsesEasyInputMessageContent1$inboundSchema;
+    /** @deprecated use `OpenResponsesEasyInputMessageContent1$outboundSchema` instead. */
+    OpenResponsesEasyInputMessageContent1$.outboundSchema = OpenResponsesEasyInputMessageContent1$outboundSchema;
+})(OpenResponsesEasyInputMessageContent1$ || (OpenResponsesEasyInputMessageContent1$ = {}));
+export function openResponsesEasyInputMessageContent1ToJSON(openResponsesEasyInputMessageContent1) {
+    return JSON.stringify(OpenResponsesEasyInputMessageContent1$outboundSchema.parse(openResponsesEasyInputMessageContent1));
+}
+export function openResponsesEasyInputMessageContent1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesEasyInputMessageContent1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesEasyInputMessageContent1' from JSON`);
+}
 /** @internal */
-export const OpenResponsesEasyInputMessageContent$outboundSchema = z.union([z.array(OpenResponsesInputContent$outboundSchema), z.string()]);
+export const OpenResponsesEasyInputMessageContent2$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 OpenResponsesEasyInputMessageContent2$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 OpenResponsesEasyInputMessageContent$;
-(function (OpenResponsesEasyInputMessageContent$) {
-    /** @deprecated use `OpenResponsesEasyInputMessageContent$inboundSchema` instead. */
-    OpenResponsesEasyInputMessageContent$.inboundSchema = OpenResponsesEasyInputMessageContent$inboundSchema;
-    /** @deprecated use `OpenResponsesEasyInputMessageContent$outboundSchema` instead. */
-    OpenResponsesEasyInputMessageContent$.outboundSchema = OpenResponsesEasyInputMessageContent$outboundSchema;
-})(OpenResponsesEasyInputMessageContent$ || (OpenResponsesEasyInputMessageContent$ = {}));
-export function openResponsesEasyInputMessageContentToJSON(openResponsesEasyInputMessageContent) {
-    return JSON.stringify(OpenResponsesEasyInputMessageContent$outboundSchema.parse(openResponsesEasyInputMessageContent));
+export var OpenResponsesEasyInputMessageContent2$;
+(function (OpenResponsesEasyInputMessageContent2$) {
+    /** @deprecated use `OpenResponsesEasyInputMessageContent2$inboundSchema` instead. */
+    OpenResponsesEasyInputMessageContent2$.inboundSchema = OpenResponsesEasyInputMessageContent2$inboundSchema;
+    /** @deprecated use `OpenResponsesEasyInputMessageContent2$outboundSchema` instead. */
+    OpenResponsesEasyInputMessageContent2$.outboundSchema = OpenResponsesEasyInputMessageContent2$outboundSchema;
+})(OpenResponsesEasyInputMessageContent2$ || (OpenResponsesEasyInputMessageContent2$ = {}));
+export function openResponsesEasyInputMessageContent2ToJSON(openResponsesEasyInputMessageContent2) {
+    return JSON.stringify(OpenResponsesEasyInputMessageContent2$outboundSchema.parse(openResponsesEasyInputMessageContent2));
 }
-export function openResponsesEasyInputMessageContentFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesEasyInputMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesEasyInputMessageContent' from JSON`);
+export function openResponsesEasyInputMessageContent2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesEasyInputMessageContent2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesEasyInputMessageContent2' from JSON`);
 }
 /** @internal */
 export const OpenResponsesEasyInputMessage$inboundSchema = z.object({
@@ -156,7 +225,17 @@ export const OpenResponsesEasyInputMessage$inboundSchema = z.object({
         OpenResponsesEasyInputMessageRoleDeveloper$inboundSchema,
     ]),
     content: z.union([
-        z.array(OpenResponsesInputContent$inboundSchema),
+        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(),
     ]),
 });
@@ -170,7 +249,17 @@ export const OpenResponsesEasyInputMessage$outboundSchema = z.object({
         OpenResponsesEasyInputMessageRoleDeveloper$outboundSchema,
     ]),
     content: z.union([
-        z.array(OpenResponsesInputContent$outboundSchema),
+        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(),
     ]),
 });

package/esm/models/openresponseserrorevent.d.ts

@@ -0,0 +1,63 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesErrorEventType: {
+    readonly Error: "error";
+};
+export type OpenResponsesErrorEventType = ClosedEnum<typeof OpenResponsesErrorEventType>;
+/**
+ * Event emitted when an error occurs during streaming
+ */
+export type OpenResponsesErrorEvent = {
+    type: OpenResponsesErrorEventType;
+    code: string | null;
+    message: string;
+    param: string | null;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesErrorEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesErrorEventType>;
+/** @internal */
+export declare const OpenResponsesErrorEventType$outboundSchema: z.ZodEnum<typeof OpenResponsesErrorEventType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesErrorEventType$ {
+    /** @deprecated use `OpenResponsesErrorEventType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly Error: "error";
+    }>;
+    /** @deprecated use `OpenResponsesErrorEventType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly Error: "error";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesErrorEvent$inboundSchema: z.ZodType<OpenResponsesErrorEvent, unknown>;
+/** @internal */
+export type OpenResponsesErrorEvent$Outbound = {
+    type: string;
+    code: string | null;
+    message: string;
+    param: string | null;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesErrorEvent$outboundSchema: z.ZodType<OpenResponsesErrorEvent$Outbound, OpenResponsesErrorEvent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesErrorEvent$ {
+    /** @deprecated use `OpenResponsesErrorEvent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesErrorEvent, unknown, z.core.$ZodTypeInternals<OpenResponsesErrorEvent, unknown>>;
+    /** @deprecated use `OpenResponsesErrorEvent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesErrorEvent$Outbound, OpenResponsesErrorEvent, z.core.$ZodTypeInternals<OpenResponsesErrorEvent$Outbound, OpenResponsesErrorEvent>>;
+    /** @deprecated use `OpenResponsesErrorEvent$Outbound` instead. */
+    type Outbound = OpenResponsesErrorEvent$Outbound;
+}
+export declare function openResponsesErrorEventToJSON(openResponsesErrorEvent: OpenResponsesErrorEvent): string;
+export declare function openResponsesErrorEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesErrorEvent, SDKValidationError>;
+//# sourceMappingURL=openresponseserrorevent.d.ts.map

package/esm/models/openresponseserrorevent.js

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesErrorEventType = {
+    Error: "error",
+};
+/** @internal */
+export const OpenResponsesErrorEventType$inboundSchema = z.enum(OpenResponsesErrorEventType);
+/** @internal */
+export const OpenResponsesErrorEventType$outboundSchema = OpenResponsesErrorEventType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesErrorEventType$;
+(function (OpenResponsesErrorEventType$) {
+    /** @deprecated use `OpenResponsesErrorEventType$inboundSchema` instead. */
+    OpenResponsesErrorEventType$.inboundSchema = OpenResponsesErrorEventType$inboundSchema;
+    /** @deprecated use `OpenResponsesErrorEventType$outboundSchema` instead. */
+    OpenResponsesErrorEventType$.outboundSchema = OpenResponsesErrorEventType$outboundSchema;
+})(OpenResponsesErrorEventType$ || (OpenResponsesErrorEventType$ = {}));
+/** @internal */
+export const OpenResponsesErrorEvent$inboundSchema = z.object({
+    type: OpenResponsesErrorEventType$inboundSchema,
+    code: z.nullable(z.string()),
+    message: z.string(),
+    param: z.nullable(z.string()),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesErrorEvent$outboundSchema = z.object({
+    type: OpenResponsesErrorEventType$outboundSchema,
+    code: z.nullable(z.string()),
+    message: z.string(),
+    param: z.nullable(z.string()),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesErrorEvent$;
+(function (OpenResponsesErrorEvent$) {
+    /** @deprecated use `OpenResponsesErrorEvent$inboundSchema` instead. */
+    OpenResponsesErrorEvent$.inboundSchema = OpenResponsesErrorEvent$inboundSchema;
+    /** @deprecated use `OpenResponsesErrorEvent$outboundSchema` instead. */
+    OpenResponsesErrorEvent$.outboundSchema = OpenResponsesErrorEvent$outboundSchema;
+})(OpenResponsesErrorEvent$ || (OpenResponsesErrorEvent$ = {}));
+export function openResponsesErrorEventToJSON(openResponsesErrorEvent) {
+    return JSON.stringify(OpenResponsesErrorEvent$outboundSchema.parse(openResponsesErrorEvent));
+}
+export function openResponsesErrorEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesErrorEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesErrorEvent' from JSON`);
+}
+//# sourceMappingURL=openresponseserrorevent.js.map

package/esm/models/openresponsesimagegencallcompleted.d.ts

@@ -0,0 +1,61 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesImageGenCallCompletedType: {
+    readonly ResponseImageGenerationCallCompleted: "response.image_generation_call.completed";
+};
+export type OpenResponsesImageGenCallCompletedType = ClosedEnum<typeof OpenResponsesImageGenCallCompletedType>;
+/**
+ * Image generation call completed
+ */
+export type OpenResponsesImageGenCallCompleted = {
+    type: OpenResponsesImageGenCallCompletedType;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesImageGenCallCompletedType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallCompletedType>;
+/** @internal */
+export declare const OpenResponsesImageGenCallCompletedType$outboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallCompletedType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesImageGenCallCompletedType$ {
+    /** @deprecated use `OpenResponsesImageGenCallCompletedType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseImageGenerationCallCompleted: "response.image_generation_call.completed";
+    }>;
+    /** @deprecated use `OpenResponsesImageGenCallCompletedType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseImageGenerationCallCompleted: "response.image_generation_call.completed";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesImageGenCallCompleted$inboundSchema: z.ZodType<OpenResponsesImageGenCallCompleted, unknown>;
+/** @internal */
+export type OpenResponsesImageGenCallCompleted$Outbound = {
+    type: string;
+    item_id: string;
+    output_index: number;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesImageGenCallCompleted$outboundSchema: z.ZodType<OpenResponsesImageGenCallCompleted$Outbound, OpenResponsesImageGenCallCompleted>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesImageGenCallCompleted$ {
+    /** @deprecated use `OpenResponsesImageGenCallCompleted$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesImageGenCallCompleted, unknown, z.core.$ZodTypeInternals<OpenResponsesImageGenCallCompleted, unknown>>;
+    /** @deprecated use `OpenResponsesImageGenCallCompleted$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesImageGenCallCompleted$Outbound, OpenResponsesImageGenCallCompleted, z.core.$ZodTypeInternals<OpenResponsesImageGenCallCompleted$Outbound, OpenResponsesImageGenCallCompleted>>;
+    /** @deprecated use `OpenResponsesImageGenCallCompleted$Outbound` instead. */
+    type Outbound = OpenResponsesImageGenCallCompleted$Outbound;
+}
+export declare function openResponsesImageGenCallCompletedToJSON(openResponsesImageGenCallCompleted: OpenResponsesImageGenCallCompleted): string;
+export declare function openResponsesImageGenCallCompletedFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallCompleted, SDKValidationError>;
+//# sourceMappingURL=openresponsesimagegencallcompleted.d.ts.map

package/esm/models/openresponsesimagegencallcompleted.js

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesImageGenCallCompletedType = {
+    ResponseImageGenerationCallCompleted: "response.image_generation_call.completed",
+};
+/** @internal */
+export const OpenResponsesImageGenCallCompletedType$inboundSchema = z.enum(OpenResponsesImageGenCallCompletedType);
+/** @internal */
+export const OpenResponsesImageGenCallCompletedType$outboundSchema = OpenResponsesImageGenCallCompletedType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesImageGenCallCompletedType$;
+(function (OpenResponsesImageGenCallCompletedType$) {
+    /** @deprecated use `OpenResponsesImageGenCallCompletedType$inboundSchema` instead. */
+    OpenResponsesImageGenCallCompletedType$.inboundSchema = OpenResponsesImageGenCallCompletedType$inboundSchema;
+    /** @deprecated use `OpenResponsesImageGenCallCompletedType$outboundSchema` instead. */
+    OpenResponsesImageGenCallCompletedType$.outboundSchema = OpenResponsesImageGenCallCompletedType$outboundSchema;
+})(OpenResponsesImageGenCallCompletedType$ || (OpenResponsesImageGenCallCompletedType$ = {}));
+/** @internal */
+export const OpenResponsesImageGenCallCompleted$inboundSchema = z.object({
+    type: OpenResponsesImageGenCallCompletedType$inboundSchema,
+    item_id: z.string(),
+    output_index: z.number(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesImageGenCallCompleted$outboundSchema = z.object({
+    type: OpenResponsesImageGenCallCompletedType$outboundSchema,
+    itemId: z.string(),
+    outputIndex: z.number(),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        itemId: "item_id",
+        outputIndex: "output_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesImageGenCallCompleted$;
+(function (OpenResponsesImageGenCallCompleted$) {
+    /** @deprecated use `OpenResponsesImageGenCallCompleted$inboundSchema` instead. */
+    OpenResponsesImageGenCallCompleted$.inboundSchema = OpenResponsesImageGenCallCompleted$inboundSchema;
+    /** @deprecated use `OpenResponsesImageGenCallCompleted$outboundSchema` instead. */
+    OpenResponsesImageGenCallCompleted$.outboundSchema = OpenResponsesImageGenCallCompleted$outboundSchema;
+})(OpenResponsesImageGenCallCompleted$ || (OpenResponsesImageGenCallCompleted$ = {}));
+export function openResponsesImageGenCallCompletedToJSON(openResponsesImageGenCallCompleted) {
+    return JSON.stringify(OpenResponsesImageGenCallCompleted$outboundSchema.parse(openResponsesImageGenCallCompleted));
+}
+export function openResponsesImageGenCallCompletedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesImageGenCallCompleted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallCompleted' from JSON`);
+}
+//# sourceMappingURL=openresponsesimagegencallcompleted.js.map

package/esm/models/openresponsesimagegencallgenerating.d.ts

@@ -0,0 +1,61 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesImageGenCallGeneratingType: {
+    readonly ResponseImageGenerationCallGenerating: "response.image_generation_call.generating";
+};
+export type OpenResponsesImageGenCallGeneratingType = ClosedEnum<typeof OpenResponsesImageGenCallGeneratingType>;
+/**
+ * Image generation call is generating
+ */
+export type OpenResponsesImageGenCallGenerating = {
+    type: OpenResponsesImageGenCallGeneratingType;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesImageGenCallGeneratingType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallGeneratingType>;
+/** @internal */
+export declare const OpenResponsesImageGenCallGeneratingType$outboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallGeneratingType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesImageGenCallGeneratingType$ {
+    /** @deprecated use `OpenResponsesImageGenCallGeneratingType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseImageGenerationCallGenerating: "response.image_generation_call.generating";
+    }>;
+    /** @deprecated use `OpenResponsesImageGenCallGeneratingType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseImageGenerationCallGenerating: "response.image_generation_call.generating";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesImageGenCallGenerating$inboundSchema: z.ZodType<OpenResponsesImageGenCallGenerating, unknown>;
+/** @internal */
+export type OpenResponsesImageGenCallGenerating$Outbound = {
+    type: string;
+    item_id: string;
+    output_index: number;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesImageGenCallGenerating$outboundSchema: z.ZodType<OpenResponsesImageGenCallGenerating$Outbound, OpenResponsesImageGenCallGenerating>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesImageGenCallGenerating$ {
+    /** @deprecated use `OpenResponsesImageGenCallGenerating$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesImageGenCallGenerating, unknown, z.core.$ZodTypeInternals<OpenResponsesImageGenCallGenerating, unknown>>;
+    /** @deprecated use `OpenResponsesImageGenCallGenerating$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesImageGenCallGenerating$Outbound, OpenResponsesImageGenCallGenerating, z.core.$ZodTypeInternals<OpenResponsesImageGenCallGenerating$Outbound, OpenResponsesImageGenCallGenerating>>;
+    /** @deprecated use `OpenResponsesImageGenCallGenerating$Outbound` instead. */
+    type Outbound = OpenResponsesImageGenCallGenerating$Outbound;
+}
+export declare function openResponsesImageGenCallGeneratingToJSON(openResponsesImageGenCallGenerating: OpenResponsesImageGenCallGenerating): string;
+export declare function openResponsesImageGenCallGeneratingFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallGenerating, SDKValidationError>;
+//# sourceMappingURL=openresponsesimagegencallgenerating.d.ts.map

package/esm/models/openresponsesimagegencallgenerating.js

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesImageGenCallGeneratingType = {
+    ResponseImageGenerationCallGenerating: "response.image_generation_call.generating",
+};
+/** @internal */
+export const OpenResponsesImageGenCallGeneratingType$inboundSchema = z.enum(OpenResponsesImageGenCallGeneratingType);
+/** @internal */
+export const OpenResponsesImageGenCallGeneratingType$outboundSchema = OpenResponsesImageGenCallGeneratingType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesImageGenCallGeneratingType$;
+(function (OpenResponsesImageGenCallGeneratingType$) {
+    /** @deprecated use `OpenResponsesImageGenCallGeneratingType$inboundSchema` instead. */
+    OpenResponsesImageGenCallGeneratingType$.inboundSchema = OpenResponsesImageGenCallGeneratingType$inboundSchema;
+    /** @deprecated use `OpenResponsesImageGenCallGeneratingType$outboundSchema` instead. */
+    OpenResponsesImageGenCallGeneratingType$.outboundSchema = OpenResponsesImageGenCallGeneratingType$outboundSchema;
+})(OpenResponsesImageGenCallGeneratingType$ || (OpenResponsesImageGenCallGeneratingType$ = {}));
+/** @internal */
+export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
+    type: OpenResponsesImageGenCallGeneratingType$inboundSchema,
+    item_id: z.string(),
+    output_index: z.number(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesImageGenCallGenerating$outboundSchema = z.object({
+    type: OpenResponsesImageGenCallGeneratingType$outboundSchema,
+    itemId: z.string(),
+    outputIndex: z.number(),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        itemId: "item_id",
+        outputIndex: "output_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesImageGenCallGenerating$;
+(function (OpenResponsesImageGenCallGenerating$) {
+    /** @deprecated use `OpenResponsesImageGenCallGenerating$inboundSchema` instead. */
+    OpenResponsesImageGenCallGenerating$.inboundSchema = OpenResponsesImageGenCallGenerating$inboundSchema;
+    /** @deprecated use `OpenResponsesImageGenCallGenerating$outboundSchema` instead. */
+    OpenResponsesImageGenCallGenerating$.outboundSchema = OpenResponsesImageGenCallGenerating$outboundSchema;
+})(OpenResponsesImageGenCallGenerating$ || (OpenResponsesImageGenCallGenerating$ = {}));
+export function openResponsesImageGenCallGeneratingToJSON(openResponsesImageGenCallGenerating) {
+    return JSON.stringify(OpenResponsesImageGenCallGenerating$outboundSchema.parse(openResponsesImageGenCallGenerating));
+}
+export function openResponsesImageGenCallGeneratingFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesImageGenCallGenerating$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallGenerating' from JSON`);
+}
+//# sourceMappingURL=openresponsesimagegencallgenerating.js.map

package/esm/models/openresponsesimagegencallinprogress.d.ts

@@ -0,0 +1,61 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const OpenResponsesImageGenCallInProgressType: {
+    readonly ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress";
+};
+export type OpenResponsesImageGenCallInProgressType = ClosedEnum<typeof OpenResponsesImageGenCallInProgressType>;
+/**
+ * Image generation call in progress
+ */
+export type OpenResponsesImageGenCallInProgress = {
+    type: OpenResponsesImageGenCallInProgressType;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesImageGenCallInProgressType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallInProgressType>;
+/** @internal */
+export declare const OpenResponsesImageGenCallInProgressType$outboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallInProgressType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesImageGenCallInProgressType$ {
+    /** @deprecated use `OpenResponsesImageGenCallInProgressType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress";
+    }>;
+    /** @deprecated use `OpenResponsesImageGenCallInProgressType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesImageGenCallInProgress$inboundSchema: z.ZodType<OpenResponsesImageGenCallInProgress, unknown>;
+/** @internal */
+export type OpenResponsesImageGenCallInProgress$Outbound = {
+    type: string;
+    item_id: string;
+    output_index: number;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesImageGenCallInProgress$outboundSchema: z.ZodType<OpenResponsesImageGenCallInProgress$Outbound, OpenResponsesImageGenCallInProgress>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesImageGenCallInProgress$ {
+    /** @deprecated use `OpenResponsesImageGenCallInProgress$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesImageGenCallInProgress, unknown, z.core.$ZodTypeInternals<OpenResponsesImageGenCallInProgress, unknown>>;
+    /** @deprecated use `OpenResponsesImageGenCallInProgress$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesImageGenCallInProgress$Outbound, OpenResponsesImageGenCallInProgress, z.core.$ZodTypeInternals<OpenResponsesImageGenCallInProgress$Outbound, OpenResponsesImageGenCallInProgress>>;
+    /** @deprecated use `OpenResponsesImageGenCallInProgress$Outbound` instead. */
+    type Outbound = OpenResponsesImageGenCallInProgress$Outbound;
+}
+export declare function openResponsesImageGenCallInProgressToJSON(openResponsesImageGenCallInProgress: OpenResponsesImageGenCallInProgress): string;
+export declare function openResponsesImageGenCallInProgressFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallInProgress, SDKValidationError>;
+//# sourceMappingURL=openresponsesimagegencallinprogress.d.ts.map