@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/functioncallargsdoneevent.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b2142af551f4
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FunctionCallArgsDoneEvent$inboundSchema = z.object({
+    arguments: z.string(),
+    item_id: z.string(),
+    name: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.function_call_arguments.done"),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function functionCallArgsDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FunctionCallArgsDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FunctionCallArgsDoneEvent' from JSON`);
+}
+//# sourceMappingURL=functioncallargsdoneevent.js.map

package/esm/models/functioncallitem.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const FunctionCallItemType: {
+    readonly FunctionCall: "function_call";
+};
+export type FunctionCallItemType = ClosedEnum<typeof FunctionCallItemType>;
+/**
+ * A function call initiated by the model
+ */
+export type FunctionCallItem = {
+    arguments: string;
+    callId: string;
+    id: string;
+    name: string;
+    status?: ToolCallStatus | undefined;
+    type: FunctionCallItemType;
+};
+/** @internal */
+export declare const FunctionCallItemType$outboundSchema: z.ZodEnum<typeof FunctionCallItemType>;
+/** @internal */
+export type FunctionCallItem$Outbound = {
+    arguments: string;
+    call_id: string;
+    id: string;
+    name: string;
+    status?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const FunctionCallItem$outboundSchema: z.ZodType<FunctionCallItem$Outbound, FunctionCallItem>;
+export declare function functionCallItemToJSON(functionCallItem: FunctionCallItem): string;
+//# sourceMappingURL=functioncallitem.d.ts.map

package/esm/models/functioncallitem.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7e96e10e664b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const FunctionCallItemType = {
+    FunctionCall: "function_call",
+};
+/** @internal */
+export const FunctionCallItemType$outboundSchema = z.enum(FunctionCallItemType);
+/** @internal */
+export const FunctionCallItem$outboundSchema = z.object({
+    arguments: z.string(),
+    callId: z.string(),
+    id: z.string(),
+    name: z.string(),
+    status: ToolCallStatus$outboundSchema.optional(),
+    type: FunctionCallItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function functionCallItemToJSON(functionCallItem) {
+    return JSON.stringify(FunctionCallItem$outboundSchema.parse(functionCallItem));
+}
+//# sourceMappingURL=functioncallitem.js.map

package/esm/models/functioncalloutputitem.d.ts

@@ -0,0 +1,77 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { InputFile, InputFile$Outbound } from "./inputfile.js";
+import { InputText, InputText$Outbound } from "./inputtext.js";
+export declare const FunctionCallOutputItemDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type FunctionCallOutputItemDetail = OpenEnum<typeof FunctionCallOutputItemDetail>;
+/**
+ * Image input content item
+ */
+export type OutputInputImage = {
+    detail: FunctionCallOutputItemDetail;
+    imageUrl?: string | null | undefined;
+    type: "input_image";
+};
+export type FunctionCallOutputItemOutputUnion1 = InputText | OutputInputImage | InputFile;
+export type FunctionCallOutputItemOutputUnion2 = string | Array<InputText | OutputInputImage | InputFile>;
+export declare const FunctionCallOutputItemStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+};
+export type FunctionCallOutputItemStatus = OpenEnum<typeof FunctionCallOutputItemStatus>;
+export declare const FunctionCallOutputItemTypeFunctionCallOutput: {
+    readonly FunctionCallOutput: "function_call_output";
+};
+export type FunctionCallOutputItemTypeFunctionCallOutput = ClosedEnum<typeof FunctionCallOutputItemTypeFunctionCallOutput>;
+/**
+ * The output from a function call execution
+ */
+export type FunctionCallOutputItem = {
+    callId: string;
+    id?: string | null | undefined;
+    output: string | Array<InputText | OutputInputImage | InputFile>;
+    status?: FunctionCallOutputItemStatus | null | undefined;
+    type: FunctionCallOutputItemTypeFunctionCallOutput;
+};
+/** @internal */
+export declare const FunctionCallOutputItemDetail$outboundSchema: z.ZodType<string, FunctionCallOutputItemDetail>;
+/** @internal */
+export type OutputInputImage$Outbound = {
+    detail: string;
+    image_url?: string | null | undefined;
+    type: "input_image";
+};
+/** @internal */
+export declare const OutputInputImage$outboundSchema: z.ZodType<OutputInputImage$Outbound, OutputInputImage>;
+export declare function outputInputImageToJSON(outputInputImage: OutputInputImage): string;
+/** @internal */
+export type FunctionCallOutputItemOutputUnion1$Outbound = InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound;
+/** @internal */
+export declare const FunctionCallOutputItemOutputUnion1$outboundSchema: z.ZodType<FunctionCallOutputItemOutputUnion1$Outbound, FunctionCallOutputItemOutputUnion1>;
+export declare function functionCallOutputItemOutputUnion1ToJSON(functionCallOutputItemOutputUnion1: FunctionCallOutputItemOutputUnion1): string;
+/** @internal */
+export type FunctionCallOutputItemOutputUnion2$Outbound = string | Array<InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound>;
+/** @internal */
+export declare const FunctionCallOutputItemOutputUnion2$outboundSchema: z.ZodType<FunctionCallOutputItemOutputUnion2$Outbound, FunctionCallOutputItemOutputUnion2>;
+export declare function functionCallOutputItemOutputUnion2ToJSON(functionCallOutputItemOutputUnion2: FunctionCallOutputItemOutputUnion2): string;
+/** @internal */
+export declare const FunctionCallOutputItemStatus$outboundSchema: z.ZodType<string, FunctionCallOutputItemStatus>;
+/** @internal */
+export declare const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema: z.ZodEnum<typeof FunctionCallOutputItemTypeFunctionCallOutput>;
+/** @internal */
+export type FunctionCallOutputItem$Outbound = {
+    call_id: string;
+    id?: string | null | undefined;
+    output: string | Array<InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound>;
+    status?: string | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const FunctionCallOutputItem$outboundSchema: z.ZodType<FunctionCallOutputItem$Outbound, FunctionCallOutputItem>;
+export declare function functionCallOutputItemToJSON(functionCallOutputItem: FunctionCallOutputItem): string;
+//# sourceMappingURL=functioncalloutputitem.d.ts.map

package/esm/models/functioncalloutputitem.js

@@ -0,0 +1,85 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 279b91cadffe
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { InputFile$outboundSchema, } from "./inputfile.js";
+import { InputText$outboundSchema, } from "./inputtext.js";
+export const FunctionCallOutputItemDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+export const FunctionCallOutputItemStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+    Incomplete: "incomplete",
+};
+export const FunctionCallOutputItemTypeFunctionCallOutput = {
+    FunctionCallOutput: "function_call_output",
+};
+/** @internal */
+export const FunctionCallOutputItemDetail$outboundSchema = openEnums.outboundSchema(FunctionCallOutputItemDetail);
+/** @internal */
+export const OutputInputImage$outboundSchema = z.object({
+    detail: FunctionCallOutputItemDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+    type: z.literal("input_image"),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function outputInputImageToJSON(outputInputImage) {
+    return JSON.stringify(OutputInputImage$outboundSchema.parse(outputInputImage));
+}
+/** @internal */
+export const FunctionCallOutputItemOutputUnion1$outboundSchema = z.union([
+    InputText$outboundSchema,
+    z.lazy(() => OutputInputImage$outboundSchema),
+    InputFile$outboundSchema,
+]);
+export function functionCallOutputItemOutputUnion1ToJSON(functionCallOutputItemOutputUnion1) {
+    return JSON.stringify(FunctionCallOutputItemOutputUnion1$outboundSchema.parse(functionCallOutputItemOutputUnion1));
+}
+/** @internal */
+export const FunctionCallOutputItemOutputUnion2$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        InputText$outboundSchema,
+        z.lazy(() => OutputInputImage$outboundSchema),
+        InputFile$outboundSchema,
+    ])),
+]);
+export function functionCallOutputItemOutputUnion2ToJSON(functionCallOutputItemOutputUnion2) {
+    return JSON.stringify(FunctionCallOutputItemOutputUnion2$outboundSchema.parse(functionCallOutputItemOutputUnion2));
+}
+/** @internal */
+export const FunctionCallOutputItemStatus$outboundSchema = openEnums.outboundSchema(FunctionCallOutputItemStatus);
+/** @internal */
+export const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema = z.enum(FunctionCallOutputItemTypeFunctionCallOutput);
+/** @internal */
+export const FunctionCallOutputItem$outboundSchema = z.object({
+    callId: z.string(),
+    id: z.nullable(z.string()).optional(),
+    output: z.union([
+        z.string(),
+        z.array(z.union([
+            InputText$outboundSchema,
+            z.lazy(() => OutputInputImage$outboundSchema),
+            InputFile$outboundSchema,
+        ])),
+    ]),
+    status: z.nullable(FunctionCallOutputItemStatus$outboundSchema).optional(),
+    type: FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function functionCallOutputItemToJSON(functionCallOutputItem) {
+    return JSON.stringify(FunctionCallOutputItem$outboundSchema.parse(functionCallOutputItem));
+}
+//# sourceMappingURL=functioncalloutputitem.js.map

package/esm/models/getguardrailresponse.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Guardrail } from "./guardrail.js";
+export type GetGuardrailResponse = {
+    data: Guardrail;
+};
+/** @internal */
+export declare const GetGuardrailResponse$inboundSchema: z.ZodType<GetGuardrailResponse, unknown>;
+export declare function getGuardrailResponseFromJSON(jsonString: string): SafeParseResult<GetGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=getguardrailresponse.d.ts.map

package/esm/models/getguardrailresponse.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3103b978871a
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { Guardrail$inboundSchema } from "./guardrail.js";
+/** @internal */
+export const GetGuardrailResponse$inboundSchema = z.object({
+    data: Guardrail$inboundSchema,
+});
+export function getGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=getguardrailresponse.js.map

package/esm/models/guardrail.d.ts

@@ -0,0 +1,54 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { GuardrailInterval } from "./guardrailinterval.js";
+export type Guardrail = {
+    /**
+     * Array of model canonical_slugs (immutable identifiers)
+     */
+    allowedModels?: Array<string> | null | undefined;
+    /**
+     * List of allowed provider IDs
+     */
+    allowedProviders?: Array<string> | null | undefined;
+    /**
+     * ISO 8601 timestamp of when the guardrail was created
+     */
+    createdAt: string;
+    /**
+     * Description of the guardrail
+     */
+    description?: string | null | undefined;
+    /**
+     * Whether to enforce zero data retention
+     */
+    enforceZdr?: boolean | null | undefined;
+    /**
+     * Unique identifier for the guardrail
+     */
+    id: string;
+    /**
+     * List of provider IDs to exclude from routing
+     */
+    ignoredProviders?: Array<string> | null | undefined;
+    /**
+     * Spending limit in USD
+     */
+    limitUsd?: number | undefined;
+    /**
+     * Name of the guardrail
+     */
+    name: string;
+    /**
+     * Interval at which the limit resets (daily, weekly, monthly)
+     */
+    resetInterval?: GuardrailInterval | null | undefined;
+    /**
+     * ISO 8601 timestamp of when the guardrail was last updated
+     */
+    updatedAt?: string | null | undefined;
+};
+/** @internal */
+export declare const Guardrail$inboundSchema: z.ZodType<Guardrail, unknown>;
+export declare function guardrailFromJSON(jsonString: string): SafeParseResult<Guardrail, SDKValidationError>;
+//# sourceMappingURL=guardrail.d.ts.map

package/esm/models/guardrail.js

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 240a4b8d7a7d
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { GuardrailInterval$inboundSchema, } from "./guardrailinterval.js";
+/** @internal */
+export const Guardrail$inboundSchema = z.object({
+    allowed_models: z.nullable(z.array(z.string())).optional(),
+    allowed_providers: z.nullable(z.array(z.string())).optional(),
+    created_at: z.string(),
+    description: z.nullable(z.string()).optional(),
+    enforce_zdr: z.nullable(z.boolean()).optional(),
+    id: z.string(),
+    ignored_providers: z.nullable(z.array(z.string())).optional(),
+    limit_usd: z.number().optional(),
+    name: z.string(),
+    reset_interval: z.nullable(GuardrailInterval$inboundSchema).optional(),
+    updated_at: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "allowed_models": "allowedModels",
+        "allowed_providers": "allowedProviders",
+        "created_at": "createdAt",
+        "enforce_zdr": "enforceZdr",
+        "ignored_providers": "ignoredProviders",
+        "limit_usd": "limitUsd",
+        "reset_interval": "resetInterval",
+        "updated_at": "updatedAt",
+    });
+});
+export function guardrailFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Guardrail$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Guardrail' from JSON`);
+}
+//# sourceMappingURL=guardrail.js.map

package/esm/models/guardrailinterval.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * Interval at which the limit resets (daily, weekly, monthly)
+ */
+export declare const GuardrailInterval: {
+    readonly Daily: "daily";
+    readonly Weekly: "weekly";
+    readonly Monthly: "monthly";
+};
+/**
+ * Interval at which the limit resets (daily, weekly, monthly)
+ */
+export type GuardrailInterval = OpenEnum<typeof GuardrailInterval>;
+/** @internal */
+export declare const GuardrailInterval$inboundSchema: z.ZodType<GuardrailInterval, unknown>;
+/** @internal */
+export declare const GuardrailInterval$outboundSchema: z.ZodType<string, GuardrailInterval>;
+//# sourceMappingURL=guardrailinterval.d.ts.map

package/esm/models/guardrailinterval.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a8a819c013c0
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * Interval at which the limit resets (daily, weekly, monthly)
+ */
+export const GuardrailInterval = {
+    Daily: "daily",
+    Weekly: "weekly",
+    Monthly: "monthly",
+};
+/** @internal */
+export const GuardrailInterval$inboundSchema = openEnums.inboundSchema(GuardrailInterval);
+/** @internal */
+export const GuardrailInterval$outboundSchema = openEnums.outboundSchema(GuardrailInterval);
+//# sourceMappingURL=guardrailinterval.js.map

package/esm/models/imagegencallcompletedevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Image generation call completed
+ */
+export type ImageGenCallCompletedEvent = {
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.image_generation_call.completed";
+};
+/** @internal */
+export declare const ImageGenCallCompletedEvent$inboundSchema: z.ZodType<ImageGenCallCompletedEvent, unknown>;
+export declare function imageGenCallCompletedEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallCompletedEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallcompletedevent.d.ts.map

package/esm/models/{openresponsesimagegencallcompleted.js → imagegencallcompletedevent.js}

@@ -1,16 +1,16 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 8f2a1c3fbf5d
+ * @generated-id: fe8d977c7dca
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallCompleted$inboundSchema = z.object({
-    type: z.literal("response.image_generation_call.completed"),
+export const ImageGenCallCompletedEvent$inboundSchema = z.object({
     item_id: z.string(),
-    output_index: z.number(),
-    sequence_number: z.number(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.image_generation_call.completed"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",
@@ -18,7 +18,7 @@ export const OpenResponsesImageGenCallCompleted$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallCompletedFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallCompleted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallCompleted' from JSON`);
+export function imageGenCallCompletedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallCompletedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallCompletedEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallcompleted.js.map
+//# sourceMappingURL=imagegencallcompletedevent.js.map

package/esm/models/imagegencallgeneratingevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Image generation call is generating
+ */
+export type ImageGenCallGeneratingEvent = {
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.image_generation_call.generating";
+};
+/** @internal */
+export declare const ImageGenCallGeneratingEvent$inboundSchema: z.ZodType<ImageGenCallGeneratingEvent, unknown>;
+export declare function imageGenCallGeneratingEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallGeneratingEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallgeneratingevent.d.ts.map

package/esm/models/{openresponsesimagegencallgenerating.js → imagegencallgeneratingevent.js}

@@ -1,16 +1,16 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 97b22c3fad75
+ * @generated-id: f2806bd9c69c
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
-    type: z.literal("response.image_generation_call.generating"),
+export const ImageGenCallGeneratingEvent$inboundSchema = z.object({
     item_id: z.string(),
-    output_index: z.number(),
-    sequence_number: z.number(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.image_generation_call.generating"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",
@@ -18,7 +18,7 @@ export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallGeneratingFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallGenerating$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallGenerating' from JSON`);
+export function imageGenCallGeneratingEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallGeneratingEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallGeneratingEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallgenerating.js.map
+//# sourceMappingURL=imagegencallgeneratingevent.js.map

package/esm/models/imagegencallinprogressevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Image generation call in progress
+ */
+export type ImageGenCallInProgressEvent = {
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.image_generation_call.in_progress";
+};
+/** @internal */
+export declare const ImageGenCallInProgressEvent$inboundSchema: z.ZodType<ImageGenCallInProgressEvent, unknown>;
+export declare function imageGenCallInProgressEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallInProgressEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallinprogressevent.d.ts.map

package/esm/models/{openresponsesimagegencallinprogress.js → imagegencallinprogressevent.js}

@@ -1,16 +1,16 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 402a8da9c8da
+ * @generated-id: f9385ea6a417
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallInProgress$inboundSchema = z.object({
-    type: z.literal("response.image_generation_call.in_progress"),
+export const ImageGenCallInProgressEvent$inboundSchema = z.object({
     item_id: z.string(),
-    output_index: z.number(),
-    sequence_number: z.number(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.image_generation_call.in_progress"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",
@@ -18,7 +18,7 @@ export const OpenResponsesImageGenCallInProgress$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallInProgressFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallInProgress$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallInProgress' from JSON`);
+export function imageGenCallInProgressEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallInProgressEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallInProgressEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallinprogress.js.map
+//# sourceMappingURL=imagegencallinprogressevent.js.map

package/esm/models/{openresponsesimagegencallpartialimage.d.ts → imagegencallpartialimageevent.d.ts}

@@ -4,15 +4,15 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Image generation call with partial image
  */
-export type OpenResponsesImageGenCallPartialImage = {
-    type: "response.image_generation_call.partial_image";
+export type ImageGenCallPartialImageEvent = {
     itemId: string;
     outputIndex: number;
-    sequenceNumber: number;
     partialImageB64: string;
     partialImageIndex: number;
+    sequenceNumber: number;
+    type: "response.image_generation_call.partial_image";
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallPartialImage$inboundSchema: z.ZodType<OpenResponsesImageGenCallPartialImage, unknown>;
-export declare function openResponsesImageGenCallPartialImageFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallPartialImage, SDKValidationError>;
-//# sourceMappingURL=openresponsesimagegencallpartialimage.d.ts.map
+export declare const ImageGenCallPartialImageEvent$inboundSchema: z.ZodType<ImageGenCallPartialImageEvent, unknown>;
+export declare function imageGenCallPartialImageEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallPartialImageEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallpartialimageevent.d.ts.map

package/esm/models/{openresponsesimagegencallpartialimage.js → imagegencallpartialimageevent.js}

@@ -1,28 +1,28 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 053a18912617
+ * @generated-id: db1f02788378
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallPartialImage$inboundSchema = z.object({
-    type: z.literal("response.image_generation_call.partial_image"),
+export const ImageGenCallPartialImageEvent$inboundSchema = z.object({
     item_id: z.string(),
-    output_index: z.number(),
-    sequence_number: z.number(),
+    output_index: z.int(),
     partial_image_b64: z.string(),
-    partial_image_index: z.number(),
+    partial_image_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.image_generation_call.partial_image"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",
         "output_index": "outputIndex",
-        "sequence_number": "sequenceNumber",
         "partial_image_b64": "partialImageB64",
         "partial_image_index": "partialImageIndex",
+        "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallPartialImageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallPartialImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallPartialImage' from JSON`);
+export function imageGenCallPartialImageEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallPartialImageEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallPartialImageEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallpartialimage.js.map
+//# sourceMappingURL=imagegencallpartialimageevent.js.map