@openrouter/sdk 0.1.10 → 0.1.13

package/esm/lib/config.d.ts

@@ -37,8 +37,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.1.10";
-    readonly genVersion: "2.748.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.10 2.748.4 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.1.13";
+    readonly genVersion: "2.755.9";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.13 2.755.9 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.1.10",
-    genVersion: "2.748.4",
-    userAgent: "speakeasy-sdk/typescript 0.1.10 2.748.4 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.1.13",
+    genVersion: "2.755.9",
+    userAgent: "speakeasy-sdk/typescript 0.1.13 2.755.9 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/chatgenerationparams.d.ts

@@ -7,6 +7,7 @@ import { ResponseFormatJSONSchema, ResponseFormatJSONSchema$Outbound } from "./r
 import { ResponseFormatTextGrammar, ResponseFormatTextGrammar$Outbound } from "./responseformattextgrammar.js";
 import { ToolDefinitionJson, ToolDefinitionJson$Outbound } from "./tooldefinitionjson.js";
 export declare const Effort: {
+    readonly None: "none";
     readonly Minimal: "minimal";
     readonly Low: "low";
     readonly Medium: "medium";
@@ -57,7 +58,7 @@ export type ChatGenerationParams = {
     user?: string | undefined;
 };
 /** @internal */
-export declare const Effort$outboundSchema: z.ZodType<Effort, Effort>;
+export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
 /** @internal */
 export type Reasoning$Outbound = {
     effort?: string | null | undefined;

package/esm/models/chatgenerationparams.js

@@ -3,6 +3,7 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
 import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
 import { Message$outboundSchema, } from "./message.js";
 import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
@@ -10,16 +11,15 @@ import { ResponseFormatJSONSchema$outboundSchema, } from "./responseformatjsonsc
 import { ResponseFormatTextGrammar$outboundSchema, } from "./responseformattextgrammar.js";
 import { ToolDefinitionJson$outboundSchema, } from "./tooldefinitionjson.js";
 export const Effort = {
+    None: "none",
     Minimal: "minimal",
     Low: "low",
     Medium: "medium",
     High: "high",
 };
 /** @internal */
-export const Effort$outboundSchema = z.union([
-    z.enum(Effort),
-    z.string().and(z.custom()),
-]);
+export const Effort$outboundSchema = openEnums
+    .outboundSchema(Effort);
 /** @internal */
 export const Reasoning$outboundSchema = z.object({
     effort: z.nullable(Effort$outboundSchema).optional(),

package/esm/models/chatmessagecontentitem.d.ts

@@ -13,6 +13,8 @@ export type ChatMessageContentItem = (ChatMessageContentItemText & {
     type: "input_audio";
 }) | (ChatMessageContentItemVideo & {
     type: "input_video";
+}) | (ChatMessageContentItemVideo & {
+    type: "video_url";
 });
 /** @internal */
 export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
@@ -25,6 +27,8 @@ export type ChatMessageContentItem$Outbound = (ChatMessageContentItemText$Outbou
     type: "input_audio";
 }) | (ChatMessageContentItemVideo$Outbound & {
     type: "input_video";
+}) | (ChatMessageContentItemVideo$Outbound & {
+    type: "video_url";
 });
 /** @internal */
 export declare const ChatMessageContentItem$outboundSchema: z.ZodType<ChatMessageContentItem$Outbound, ChatMessageContentItem>;

package/esm/models/chatmessagecontentitem.js

@@ -13,6 +13,7 @@ export const ChatMessageContentItem$inboundSchema = z.union([
     ChatMessageContentItemImage$inboundSchema.and(z.object({ type: z.literal("image_url") })),
     ChatMessageContentItemAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
     ChatMessageContentItemVideo$inboundSchema.and(z.object({ type: z.literal("input_video") })),
+    z.lazy(() => ChatMessageContentItemVideo$inboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);
 /** @internal */
 export const ChatMessageContentItem$outboundSchema = z.union([
@@ -20,6 +21,7 @@ export const ChatMessageContentItem$outboundSchema = z.union([
     ChatMessageContentItemImage$outboundSchema.and(z.object({ type: z.literal("image_url") })),
     ChatMessageContentItemAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
     ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") })),
+    z.lazy(() => ChatMessageContentItemVideo$outboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);
 export function chatMessageContentItemToJSON(chatMessageContentItem) {
     return JSON.stringify(ChatMessageContentItem$outboundSchema.parse(chatMessageContentItem));

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -23,7 +23,7 @@ export type ChatMessageContentItemAudio = {
 /** @internal */
 export declare const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown>;
 /** @internal */
-export declare const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, ChatMessageContentItemAudioFormat>;
+export declare const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<string, ChatMessageContentItemAudioFormat>;
 /** @internal */
 export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */

package/esm/models/chatmessagecontentitemaudio.js

@@ -4,7 +4,7 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
 export const ChatMessageContentItemAudioFormat = {
     Wav: "wav",
     Mp3: "mp3",
@@ -15,16 +15,9 @@ export const ChatMessageContentItemAudioFormat = {
     Pcm24: "pcm24",
 };
 /** @internal */
-export const ChatMessageContentItemAudioFormat$inboundSchema = z
-    .union([
-    z.enum(ChatMessageContentItemAudioFormat),
-    z.string().transform(catchUnrecognizedEnum),
-]);
+export const ChatMessageContentItemAudioFormat$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemAudioFormat);
 /** @internal */
-export const ChatMessageContentItemAudioFormat$outboundSchema = z.union([
-    z.enum(ChatMessageContentItemAudioFormat),
-    z.string().and(z.custom()),
-]);
+export const ChatMessageContentItemAudioFormat$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemAudioFormat);
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),

package/esm/models/chatmessagecontentitemimage.d.ts

@@ -19,7 +19,7 @@ export type ChatMessageContentItemImage = {
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$inboundSchema: z.ZodType<ChatMessageContentItemImageDetail, unknown>;
 /** @internal */
-export declare const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<ChatMessageContentItemImageDetail, ChatMessageContentItemImageDetail>;
+export declare const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<string, ChatMessageContentItemImageDetail>;
 /** @internal */
 export declare const ImageUrl$inboundSchema: z.ZodType<ImageUrl, unknown>;
 /** @internal */

package/esm/models/chatmessagecontentitemimage.js

@@ -4,23 +4,16 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
 export const ChatMessageContentItemImageDetail = {
     Auto: "auto",
     Low: "low",
     High: "high",
 };
 /** @internal */
-export const ChatMessageContentItemImageDetail$inboundSchema = z
-    .union([
-    z.enum(ChatMessageContentItemImageDetail),
-    z.string().transform(catchUnrecognizedEnum),
-]);
+export const ChatMessageContentItemImageDetail$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemImageDetail);
 /** @internal */
-export const ChatMessageContentItemImageDetail$outboundSchema = z.union([
-    z.enum(ChatMessageContentItemImageDetail),
-    z.string().and(z.custom()),
-]);
+export const ChatMessageContentItemImageDetail$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemImageDetail);
 /** @internal */
 export const ImageUrl$inboundSchema = z.object({
     url: z.string(),

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,31 +1,68 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoUrl = {
+export type VideoUrl2 = {
     url: string;
 };
-export type ChatMessageContentItemVideo = {
+export type ChatMessageContentItemVideoVideoURL = {
+    type: "video_url";
+    videoUrl: VideoUrl2;
+};
+export type VideoUrl1 = {
+    url: string;
+};
+export type ChatMessageContentItemVideoInputVideo = {
     type: "input_video";
-    videoUrl: VideoUrl;
+    videoUrl: VideoUrl1;
 };
+export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
 /** @internal */
-export declare const VideoUrl$inboundSchema: z.ZodType<VideoUrl, unknown>;
+export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
 /** @internal */
-export type VideoUrl$Outbound = {
+export type VideoUrl2$Outbound = {
     url: string;
 };
 /** @internal */
-export declare const VideoUrl$outboundSchema: z.ZodType<VideoUrl$Outbound, VideoUrl>;
-export declare function videoUrlToJSON(videoUrl: VideoUrl): string;
-export declare function videoUrlFromJSON(jsonString: string): SafeParseResult<VideoUrl, SDKValidationError>;
+export declare const VideoUrl2$outboundSchema: z.ZodType<VideoUrl2$Outbound, VideoUrl2>;
+export declare function videoUrl2ToJSON(videoUrl2: VideoUrl2): string;
+export declare function videoUrl2FromJSON(jsonString: string): SafeParseResult<VideoUrl2, SDKValidationError>;
 /** @internal */
-export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
+export declare const ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
 /** @internal */
-export type ChatMessageContentItemVideo$Outbound = {
+export type ChatMessageContentItemVideoVideoURL$Outbound = {
+    type: "video_url";
+    video_url: VideoUrl2$Outbound;
+};
+/** @internal */
+export declare const ChatMessageContentItemVideoVideoURL$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL$Outbound, ChatMessageContentItemVideoVideoURL>;
+export declare function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL: ChatMessageContentItemVideoVideoURL): string;
+export declare function chatMessageContentItemVideoVideoURLFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoURL, SDKValidationError>;
+/** @internal */
+export declare const VideoUrl1$inboundSchema: z.ZodType<VideoUrl1, unknown>;
+/** @internal */
+export type VideoUrl1$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const VideoUrl1$outboundSchema: z.ZodType<VideoUrl1$Outbound, VideoUrl1>;
+export declare function videoUrl1ToJSON(videoUrl1: VideoUrl1): string;
+export declare function videoUrl1FromJSON(jsonString: string): SafeParseResult<VideoUrl1, SDKValidationError>;
+/** @internal */
+export declare const ChatMessageContentItemVideoInputVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideoInputVideo$Outbound = {
     type: "input_video";
-    video_url: VideoUrl$Outbound;
+    video_url: VideoUrl1$Outbound;
 };
 /** @internal */
+export declare const ChatMessageContentItemVideoInputVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo$Outbound, ChatMessageContentItemVideoInputVideo>;
+export declare function chatMessageContentItemVideoInputVideoToJSON(chatMessageContentItemVideoInputVideo: ChatMessageContentItemVideoInputVideo): string;
+export declare function chatMessageContentItemVideoInputVideoFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoInputVideo, SDKValidationError>;
+/** @internal */
+export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideo$Outbound = ChatMessageContentItemVideoInputVideo$Outbound | ChatMessageContentItemVideoVideoURL$Outbound;
+/** @internal */
 export declare const ChatMessageContentItemVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideo$Outbound, ChatMessageContentItemVideo>;
 export declare function chatMessageContentItemVideoToJSON(chatMessageContentItemVideo: ChatMessageContentItemVideo): string;
 export declare function chatMessageContentItemVideoFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideo, SDKValidationError>;

package/esm/models/chatmessagecontentitemvideo.js

@@ -5,38 +5,91 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const VideoUrl$inboundSchema = z.object({
+export const VideoUrl2$inboundSchema = z.object({
     url: z.string(),
 });
 /** @internal */
-export const VideoUrl$outboundSchema = z
-    .object({
+export const VideoUrl2$outboundSchema = z.object({
     url: z.string(),
 });
-export function videoUrlToJSON(videoUrl) {
-    return JSON.stringify(VideoUrl$outboundSchema.parse(videoUrl));
+export function videoUrl2ToJSON(videoUrl2) {
+    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
 }
-export function videoUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl' from JSON`);
+export function videoUrl2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoUrl2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl2' from JSON`);
 }
 /** @internal */
-export const ChatMessageContentItemVideo$inboundSchema = z.object({
+export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
+    type: z.literal("video_url"),
+    video_url: z.lazy(() => VideoUrl2$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "video_url": "videoUrl",
+    });
+});
+/** @internal */
+export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
+    type: z.literal("video_url"),
+    videoUrl: z.lazy(() => VideoUrl2$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL) {
+    return JSON.stringify(ChatMessageContentItemVideoVideoURL$outboundSchema.parse(chatMessageContentItemVideoVideoURL));
+}
+export function chatMessageContentItemVideoVideoURLFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoURL' from JSON`);
+}
+/** @internal */
+export const VideoUrl1$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const VideoUrl1$outboundSchema = z.object({
+    url: z.string(),
+});
+export function videoUrl1ToJSON(videoUrl1) {
+    return JSON.stringify(VideoUrl1$outboundSchema.parse(videoUrl1));
+}
+export function videoUrl1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoUrl1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl1' from JSON`);
+}
+/** @internal */
+export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
     type: z.literal("input_video"),
-    video_url: z.lazy(() => VideoUrl$inboundSchema),
+    video_url: z.lazy(() => VideoUrl1$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
     });
 });
 /** @internal */
-export const ChatMessageContentItemVideo$outboundSchema = z.object({
+export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
     type: z.literal("input_video"),
-    videoUrl: z.lazy(() => VideoUrl$outboundSchema),
+    videoUrl: z.lazy(() => VideoUrl1$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",
     });
 });
+export function chatMessageContentItemVideoInputVideoToJSON(chatMessageContentItemVideoInputVideo) {
+    return JSON.stringify(ChatMessageContentItemVideoInputVideo$outboundSchema.parse(chatMessageContentItemVideoInputVideo));
+}
+export function chatMessageContentItemVideoInputVideoFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoInputVideo$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoInputVideo' from JSON`);
+}
+/** @internal */
+export const ChatMessageContentItemVideo$inboundSchema = z.union([
+    z.lazy(() => ChatMessageContentItemVideoInputVideo$inboundSchema),
+    z.lazy(() => ChatMessageContentItemVideoVideoURL$inboundSchema),
+]);
+/** @internal */
+export const ChatMessageContentItemVideo$outboundSchema = z.union([
+    z.lazy(() => ChatMessageContentItemVideoInputVideo$outboundSchema),
+    z.lazy(() => ChatMessageContentItemVideoVideoURL$outboundSchema),
+]);
 export function chatMessageContentItemVideoToJSON(chatMessageContentItemVideo) {
     return JSON.stringify(ChatMessageContentItemVideo$outboundSchema.parse(chatMessageContentItemVideo));
 }

package/esm/models/chatresponsechoice.d.ts

@@ -1,16 +1,36 @@
 import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { AssistantMessage } from "./assistantmessage.js";
-import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
+import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatCompletionFinishReason: {
+    readonly ToolCalls: "tool_calls";
+    readonly Stop: "stop";
+    readonly Length: "length";
+    readonly ContentFilter: "content_filter";
+    readonly Error: "error";
+};
+export type ChatCompletionFinishReason = OpenEnum<typeof ChatCompletionFinishReason>;
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
+export type ChatStreamingChoice = {
+    delta: ChatStreamingMessageChunk;
+    finishReason: ChatCompletionFinishReason | null;
+    index: number;
+    logprobs?: ChatMessageTokenLogprobs | null | undefined;
+};
+/** @internal */
+export declare const ChatCompletionFinishReason$inboundSchema: z.ZodType<ChatCompletionFinishReason, unknown>;
 /** @internal */
 export declare const ChatResponseChoice$inboundSchema: z.ZodType<ChatResponseChoice, unknown>;
 export declare function chatResponseChoiceFromJSON(jsonString: string): SafeParseResult<ChatResponseChoice, SDKValidationError>;
+/** @internal */
+export declare const ChatStreamingChoice$inboundSchema: z.ZodType<ChatStreamingChoice, unknown>;
+export declare function chatStreamingChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamingChoice, SDKValidationError>;
 //# sourceMappingURL=chatresponsechoice.d.ts.map

package/esm/models/chatresponsechoice.js

@@ -4,9 +4,19 @@
 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";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
-import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
+import { ChatStreamingMessageChunk$inboundSchema, } from "./chatstreamingmessagechunk.js";
+export const ChatCompletionFinishReason = {
+    ToolCalls: "tool_calls",
+    Stop: "stop",
+    Length: "length",
+    ContentFilter: "content_filter",
+    Error: "error",
+};
+/** @internal */
+export const ChatCompletionFinishReason$inboundSchema = openEnums.inboundSchema(ChatCompletionFinishReason);
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
@@ -21,4 +31,18 @@ export const ChatResponseChoice$inboundSchema = z.object({
 export function chatResponseChoiceFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatResponseChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatResponseChoice' from JSON`);
 }
+/** @internal */
+export const ChatStreamingChoice$inboundSchema = z.object({
+    delta: ChatStreamingMessageChunk$inboundSchema,
+    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
+    index: z.number(),
+    logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "finish_reason": "finishReason",
+    });
+});
+export function chatStreamingChoiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamingChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingChoice' from JSON`);
+}
 //# sourceMappingURL=chatresponsechoice.js.map

package/esm/models/chatstreamingresponsechunk.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
-import { ChatStreamingChoice } from "./chatstreamingchoice.js";
+import { ChatStreamingChoice } from "./chatresponsechoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatStreamingResponseChunkError = {
     message: string;

package/esm/models/chatstreamingresponsechunk.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
-import { ChatStreamingChoice$inboundSchema, } from "./chatstreamingchoice.js";
+import { ChatStreamingChoice$inboundSchema, } from "./chatresponsechoice.js";
 /** @internal */
 export const ChatStreamingResponseChunkError$inboundSchema = z.object({
     message: z.string(),

package/esm/models/completionchoice.js

@@ -4,7 +4,7 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
 import { CompletionLogprobs$inboundSchema, } from "./completionlogprobs.js";
 export const CompletionFinishReason = {
     Stop: "stop",
@@ -12,11 +12,7 @@ export const CompletionFinishReason = {
     ContentFilter: "content_filter",
 };
 /** @internal */
-export const CompletionFinishReason$inboundSchema = z
-    .union([
-    z.enum(CompletionFinishReason),
-    z.string().transform(catchUnrecognizedEnum),
-]);
+export const CompletionFinishReason$inboundSchema = openEnums.inboundSchema(CompletionFinishReason);
 /** @internal */
 export const CompletionChoice$inboundSchema = z.object({
     text: z.string(),

package/esm/models/createchargerequest.d.ts

@@ -15,7 +15,7 @@ export type CreateChargeRequest = {
     chainId: ChainId;
 };
 /** @internal */
-export declare const ChainId$outboundSchema: z.ZodType<ChainId, ChainId>;
+export declare const ChainId$outboundSchema: z.ZodType<number, ChainId>;
 /** @internal */
 export type CreateChargeRequest$Outbound = {
     amount: number;

package/esm/models/createchargerequest.js

@@ -3,16 +3,15 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
 export const ChainId = {
     One: 1,
     OneHundredAndThirtySeven: 137,
     EightThousandFourHundredAndFiftyThree: 8453,
 };
 /** @internal */
-export const ChainId$outboundSchema = z.union([
-    z.enum(ChainId),
-    z.number().and(z.custom()),
-]);
+export const ChainId$outboundSchema = openEnums
+    .outboundSchemaInt(ChainId);
 /** @internal */
 export const CreateChargeRequest$outboundSchema = z.object({
     amount: z.number(),

package/esm/models/datacollection.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
+ */
+export declare const DataCollection: {
+    readonly Deny: "deny";
+    readonly Allow: "allow";
+};
+/**
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
+ */
+export type DataCollection = OpenEnum<typeof DataCollection>;
+/** @internal */
+export declare const DataCollection$outboundSchema: z.ZodType<string, DataCollection>;
+//# sourceMappingURL=datacollection.d.ts.map

package/esm/models/datacollection.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
+ */
+export const DataCollection = {
+    Deny: "deny",
+    Allow: "allow",
+};
+/** @internal */
+export const DataCollection$outboundSchema = openEnums.outboundSchema(DataCollection);
+//# sourceMappingURL=datacollection.js.map

package/esm/models/endpointstatus.js

@@ -1,8 +1,7 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
-import * as z from "zod/v4";
-import { catchUnrecognizedEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
 export const EndpointStatus = {
     Zero: 0,
     Minus1: -1,
@@ -12,9 +11,5 @@ export const EndpointStatus = {
     Minus10: -10,
 };
 /** @internal */
-export const EndpointStatus$inboundSchema = z
-    .union([
-    z.enum(EndpointStatus),
-    z.number().transform(catchUnrecognizedEnum),
-]);
+export const EndpointStatus$inboundSchema = openEnums.inboundSchemaInt(EndpointStatus);
 //# sourceMappingURL=endpointstatus.js.map

package/esm/models/imagegenerationstatus.d.ts

@@ -10,5 +10,5 @@ export type ImageGenerationStatus = OpenEnum<typeof ImageGenerationStatus>;
 /** @internal */
 export declare const ImageGenerationStatus$inboundSchema: z.ZodType<ImageGenerationStatus, unknown>;
 /** @internal */
-export declare const ImageGenerationStatus$outboundSchema: z.ZodType<ImageGenerationStatus, ImageGenerationStatus>;
+export declare const ImageGenerationStatus$outboundSchema: z.ZodType<string, ImageGenerationStatus>;
 //# sourceMappingURL=imagegenerationstatus.d.ts.map

package/esm/models/imagegenerationstatus.js

@@ -1,8 +1,7 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
-import * as z from "zod/v4";
-import { catchUnrecognizedEnum, } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
 export const ImageGenerationStatus = {
     InProgress: "in_progress",
     Completed: "completed",
@@ -10,14 +9,7 @@ export const ImageGenerationStatus = {
     Failed: "failed",
 };
 /** @internal */
-export const ImageGenerationStatus$inboundSchema = z
-    .union([
-    z.enum(ImageGenerationStatus),
-    z.string().transform(catchUnrecognizedEnum),
-]);
+export const ImageGenerationStatus$inboundSchema = openEnums.inboundSchema(ImageGenerationStatus);
 /** @internal */
-export const ImageGenerationStatus$outboundSchema = z.union([
-    z.enum(ImageGenerationStatus),
-    z.string().and(z.custom()),
-]);
+export const ImageGenerationStatus$outboundSchema = openEnums.outboundSchema(ImageGenerationStatus);
 //# sourceMappingURL=imagegenerationstatus.js.map