@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/formatjsonschemaconfig.js

@@ -6,19 +6,19 @@ import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const FormatJsonSchemaConfig$inboundSchema = z.object({
-    type: z.literal("json_schema"),
-    name: z.string(),
     description: z.string().optional(),
-    strict: z.nullable(z.boolean()).optional(),
+    name: z.string(),
     schema: z.record(z.string(), z.nullable(z.any())),
+    strict: z.nullable(z.boolean()).optional(),
+    type: z.literal("json_schema"),
 });
 /** @internal */
 export const FormatJsonSchemaConfig$outboundSchema = z.object({
-    type: z.literal("json_schema"),
-    name: z.string(),
     description: z.string().optional(),
-    strict: z.nullable(z.boolean()).optional(),
+    name: z.string(),
     schema: z.record(z.string(), z.nullable(z.any())),
+    strict: z.nullable(z.boolean()).optional(),
+    type: z.literal("json_schema"),
 });
 export function formatJsonSchemaConfigToJSON(formatJsonSchemaConfig) {
     return JSON.stringify(FormatJsonSchemaConfig$outboundSchema.parse(formatJsonSchemaConfig));

package/esm/models/formats.d.ts

@@ -1,4 +1,5 @@
 import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { FormatJsonObjectConfig, FormatJsonObjectConfig$Outbound } from "./formatjsonobjectconfig.js";
@@ -7,7 +8,7 @@ import { FormatTextConfig, FormatTextConfig$Outbound } from "./formattextconfig.
 /**
  * Text response format configuration
  */
-export type Formats = FormatTextConfig | FormatJsonObjectConfig | FormatJsonSchemaConfig;
+export type Formats = FormatTextConfig | FormatJsonObjectConfig | FormatJsonSchemaConfig | discriminatedUnionTypes.Unknown<"type">;
 /** @internal */
 export declare const Formats$inboundSchema: z.ZodType<Formats, unknown>;
 /** @internal */

package/esm/models/formats.js

@@ -4,15 +4,16 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import { FormatJsonObjectConfig$inboundSchema, FormatJsonObjectConfig$outboundSchema, } from "./formatjsonobjectconfig.js";
 import { FormatJsonSchemaConfig$inboundSchema, FormatJsonSchemaConfig$outboundSchema, } from "./formatjsonschemaconfig.js";
 import { FormatTextConfig$inboundSchema, FormatTextConfig$outboundSchema, } from "./formattextconfig.js";
 /** @internal */
-export const Formats$inboundSchema = z.union([
-    FormatTextConfig$inboundSchema,
-    FormatJsonObjectConfig$inboundSchema,
-    FormatJsonSchemaConfig$inboundSchema,
-]);
+export const Formats$inboundSchema = discriminatedUnion("type", {
+    text: FormatTextConfig$inboundSchema,
+    json_object: FormatJsonObjectConfig$inboundSchema,
+    json_schema: FormatJsonSchemaConfig$inboundSchema,
+});
 /** @internal */
 export const Formats$outboundSchema = z
     .union([

package/esm/models/frameimage.d.ts

@@ -0,0 +1,49 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+export type FrameImageImageUrl = {
+    url: string;
+};
+export declare const FrameImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type FrameImageType = ClosedEnum<typeof FrameImageType>;
+/**
+ * Whether this image represents the first or last frame of the video
+ */
+export declare const FrameType: {
+    readonly FirstFrame: "first_frame";
+    readonly LastFrame: "last_frame";
+};
+/**
+ * Whether this image represents the first or last frame of the video
+ */
+export type FrameType = OpenEnum<typeof FrameType>;
+export type FrameImage = {
+    imageUrl: FrameImageImageUrl;
+    type: FrameImageType;
+    /**
+     * Whether this image represents the first or last frame of the video
+     */
+    frameType: FrameType;
+};
+/** @internal */
+export type FrameImageImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const FrameImageImageUrl$outboundSchema: z.ZodType<FrameImageImageUrl$Outbound, FrameImageImageUrl>;
+export declare function frameImageImageUrlToJSON(frameImageImageUrl: FrameImageImageUrl): string;
+/** @internal */
+export declare const FrameImageType$outboundSchema: z.ZodEnum<typeof FrameImageType>;
+/** @internal */
+export declare const FrameType$outboundSchema: z.ZodType<string, FrameType>;
+/** @internal */
+export type FrameImage$Outbound = {
+    image_url: FrameImageImageUrl$Outbound;
+    type: string;
+    frame_type: string;
+};
+/** @internal */
+export declare const FrameImage$outboundSchema: z.ZodType<FrameImage$Outbound, FrameImage>;
+export declare function frameImageToJSON(frameImage: FrameImage): string;
+//# sourceMappingURL=frameimage.d.ts.map

package/esm/models/frameimage.js

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 97fccf1b68ca
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+export const FrameImageType = {
+    ImageUrl: "image_url",
+};
+/**
+ * Whether this image represents the first or last frame of the video
+ */
+export const FrameType = {
+    FirstFrame: "first_frame",
+    LastFrame: "last_frame",
+};
+/** @internal */
+export const FrameImageImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function frameImageImageUrlToJSON(frameImageImageUrl) {
+    return JSON.stringify(FrameImageImageUrl$outboundSchema.parse(frameImageImageUrl));
+}
+/** @internal */
+export const FrameImageType$outboundSchema = z
+    .enum(FrameImageType);
+/** @internal */
+export const FrameType$outboundSchema = openEnums
+    .outboundSchema(FrameType);
+/** @internal */
+export const FrameImage$outboundSchema = z.object({
+    imageUrl: z.lazy(() => FrameImageImageUrl$outboundSchema),
+    type: FrameImageType$outboundSchema,
+    frameType: FrameType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+        frameType: "frame_type",
+    });
+});
+export function frameImageToJSON(frameImage) {
+    return JSON.stringify(FrameImage$outboundSchema.parse(frameImage));
+}
+//# sourceMappingURL=frameimage.js.map

package/esm/models/functioncallargsdeltaevent.d.ts

@@ -5,11 +5,11 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when function call arguments are being streamed
  */
 export type FunctionCallArgsDeltaEvent = {
-    type: "response.function_call_arguments.delta";
+    delta: string;
     itemId: string;
     outputIndex: number;
-    delta: string;
     sequenceNumber: number;
+    type: "response.function_call_arguments.delta";
 };
 /** @internal */
 export declare const FunctionCallArgsDeltaEvent$inboundSchema: z.ZodType<FunctionCallArgsDeltaEvent, unknown>;

package/esm/models/functioncallargsdeltaevent.js

@@ -7,11 +7,11 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const FunctionCallArgsDeltaEvent$inboundSchema = z.object({
-    type: z.literal("response.function_call_arguments.delta"),
-    item_id: z.string(),
-    output_index: z.number(),
     delta: z.string(),
-    sequence_number: z.number(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.function_call_arguments.delta"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",

package/esm/models/functioncallargsdoneevent.d.ts

@@ -5,12 +5,12 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Event emitted when function call arguments streaming is complete
  */
 export type FunctionCallArgsDoneEvent = {
-    type: "response.function_call_arguments.done";
+    arguments: string;
     itemId: string;
-    outputIndex: number;
     name: string;
-    arguments: string;
+    outputIndex: number;
     sequenceNumber: number;
+    type: "response.function_call_arguments.done";
 };
 /** @internal */
 export declare const FunctionCallArgsDoneEvent$inboundSchema: z.ZodType<FunctionCallArgsDoneEvent, unknown>;

package/esm/models/functioncallargsdoneevent.js

@@ -7,12 +7,12 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const FunctionCallArgsDoneEvent$inboundSchema = z.object({
-    type: z.literal("response.function_call_arguments.done"),
+    arguments: z.string(),
     item_id: z.string(),
-    output_index: z.number(),
     name: z.string(),
-    arguments: z.string(),
-    sequence_number: z.number(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.function_call_arguments.done"),
 }).transform((v) => {
     return remap$(v, {
         "item_id": "itemId",

package/esm/models/functioncallitem.d.ts

@@ -1,6 +1,6 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
-import { ToolCallStatusEnum } from "./toolcallstatusenum.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
 export declare const FunctionCallItemType: {
     readonly FunctionCall: "function_call";
 };
@@ -9,23 +9,23 @@ export type FunctionCallItemType = ClosedEnum<typeof FunctionCallItemType>;
  * A function call initiated by the model
  */
 export type FunctionCallItem = {
-    type: FunctionCallItemType;
-    callId: string;
-    name: string;
     arguments: string;
+    callId: string;
     id: string;
-    status?: ToolCallStatusEnum | null | undefined;
+    name: string;
+    status?: ToolCallStatus | undefined;
+    type: FunctionCallItemType;
 };
 /** @internal */
 export declare const FunctionCallItemType$outboundSchema: z.ZodEnum<typeof FunctionCallItemType>;
 /** @internal */
 export type FunctionCallItem$Outbound = {
-    type: string;
-    call_id: string;
-    name: string;
     arguments: string;
+    call_id: string;
     id: string;
-    status?: string | null | undefined;
+    name: string;
+    status?: string | undefined;
+    type: string;
 };
 /** @internal */
 export declare const FunctionCallItem$outboundSchema: z.ZodType<FunctionCallItem$Outbound, FunctionCallItem>;

package/esm/models/functioncallitem.js

@@ -4,7 +4,7 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
-import { ToolCallStatusEnum$outboundSchema, } from "./toolcallstatusenum.js";
+import { ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
 export const FunctionCallItemType = {
     FunctionCall: "function_call",
 };
@@ -12,12 +12,12 @@ export const FunctionCallItemType = {
 export const FunctionCallItemType$outboundSchema = z.enum(FunctionCallItemType);
 /** @internal */
 export const FunctionCallItem$outboundSchema = z.object({
-    type: FunctionCallItemType$outboundSchema,
-    callId: z.string(),
-    name: z.string(),
     arguments: z.string(),
+    callId: z.string(),
     id: z.string(),
-    status: z.nullable(ToolCallStatusEnum$outboundSchema).optional(),
+    name: z.string(),
+    status: ToolCallStatus$outboundSchema.optional(),
+    type: FunctionCallItemType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",

package/esm/models/functioncalloutputitem.d.ts

@@ -2,11 +2,6 @@ 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";
-import { ToolCallStatusEnum } from "./toolcallstatusenum.js";
-export declare const FunctionCallOutputItemTypeFunctionCallOutput: {
-    readonly FunctionCallOutput: "function_call_output";
-};
-export type FunctionCallOutputItemTypeFunctionCallOutput = ClosedEnum<typeof FunctionCallOutputItemTypeFunctionCallOutput>;
 export declare const FunctionCallOutputItemDetail: {
     readonly Auto: "auto";
     readonly High: "high";
@@ -17,31 +12,39 @@ export type FunctionCallOutputItemDetail = OpenEnum<typeof FunctionCallOutputIte
  * Image input content item
  */
 export type OutputInputImage = {
-    type: "input_image";
     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 = {
-    type: FunctionCallOutputItemTypeFunctionCallOutput;
-    id?: string | null | undefined;
     callId: string;
+    id?: string | null | undefined;
     output: string | Array<InputText | OutputInputImage | InputFile>;
-    status?: ToolCallStatusEnum | null | undefined;
+    status?: FunctionCallOutputItemStatus | null | undefined;
+    type: FunctionCallOutputItemTypeFunctionCallOutput;
 };
 /** @internal */
-export declare const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema: z.ZodEnum<typeof FunctionCallOutputItemTypeFunctionCallOutput>;
-/** @internal */
 export declare const FunctionCallOutputItemDetail$outboundSchema: z.ZodType<string, FunctionCallOutputItemDetail>;
 /** @internal */
 export type OutputInputImage$Outbound = {
-    type: "input_image";
     detail: string;
     image_url?: string | null | undefined;
+    type: "input_image";
 };
 /** @internal */
 export declare const OutputInputImage$outboundSchema: z.ZodType<OutputInputImage$Outbound, OutputInputImage>;
@@ -57,12 +60,16 @@ export type FunctionCallOutputItemOutputUnion2$Outbound = string | Array<InputTe
 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 = {
-    type: string;
-    id?: string | null | undefined;
     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>;

package/esm/models/functioncalloutputitem.js

@@ -7,24 +7,26 @@ 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";
-import { ToolCallStatusEnum$outboundSchema, } from "./toolcallstatusenum.js";
-export const FunctionCallOutputItemTypeFunctionCallOutput = {
-    FunctionCallOutput: "function_call_output",
-};
 export const FunctionCallOutputItemDetail = {
     Auto: "auto",
     High: "high",
     Low: "low",
 };
-/** @internal */
-export const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema = z.enum(FunctionCallOutputItemTypeFunctionCallOutput);
+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({
-    type: z.literal("input_image"),
     detail: FunctionCallOutputItemDetail$outboundSchema,
     imageUrl: z.nullable(z.string()).optional(),
+    type: z.literal("input_image"),
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",
@@ -55,10 +57,13 @@ export function functionCallOutputItemOutputUnion2ToJSON(functionCallOutputItemO
     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({
-    type: FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema,
-    id: z.nullable(z.string()).optional(),
     callId: z.string(),
+    id: z.nullable(z.string()).optional(),
     output: z.union([
         z.string(),
         z.array(z.union([
@@ -67,7 +72,8 @@ export const FunctionCallOutputItem$outboundSchema = z.object({
             InputFile$outboundSchema,
         ])),
     ]),
-    status: z.nullable(ToolCallStatusEnum$outboundSchema).optional(),
+    status: z.nullable(FunctionCallOutputItemStatus$outboundSchema).optional(),
+    type: FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",

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

@@ -5,10 +5,10 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Image generation call completed
  */
 export type ImageGenCallCompletedEvent = {
-    type: "response.image_generation_call.completed";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
+    type: "response.image_generation_call.completed";
 };
 /** @internal */
 export declare const ImageGenCallCompletedEvent$inboundSchema: z.ZodType<ImageGenCallCompletedEvent, unknown>;

package/esm/models/imagegencallcompletedevent.js

@@ -7,10 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ImageGenCallCompletedEvent$inboundSchema = z.object({
-    type: z.literal("response.image_generation_call.completed"),
     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",

package/esm/models/imagegencallgeneratingevent.d.ts

@@ -5,10 +5,10 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  * Image generation call is generating
  */
 export type ImageGenCallGeneratingEvent = {
-    type: "response.image_generation_call.generating";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
+    type: "response.image_generation_call.generating";
 };
 /** @internal */
 export declare const ImageGenCallGeneratingEvent$inboundSchema: z.ZodType<ImageGenCallGeneratingEvent, unknown>;

package/esm/models/imagegencallgeneratingevent.js

@@ -7,10 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ImageGenCallGeneratingEvent$inboundSchema = z.object({
-    type: z.literal("response.image_generation_call.generating"),
     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",