@openrouter/sdk 0.10.2 → 0.11.2

package/esm/models/chatcontentaudio.d.ts

@@ -0,0 +1,52 @@
+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 ChatContentAudioType: {
+    readonly InputAudio: "input_audio";
+};
+export type ChatContentAudioType = ClosedEnum<typeof ChatContentAudioType>;
+export type ChatContentAudioInputAudio = {
+    /**
+     * Base64 encoded audio data
+     */
+    data: string;
+    /**
+     * Audio format (e.g., wav, mp3, flac, m4a, ogg, aiff, aac, pcm16, pcm24). Supported formats vary by provider.
+     */
+    format: string;
+};
+/**
+ * Audio input content part. Supported audio formats vary by provider.
+ */
+export type ChatContentAudio = {
+    type: ChatContentAudioType;
+    inputAudio: ChatContentAudioInputAudio;
+};
+/** @internal */
+export declare const ChatContentAudioType$inboundSchema: z.ZodEnum<typeof ChatContentAudioType>;
+/** @internal */
+export declare const ChatContentAudioType$outboundSchema: z.ZodEnum<typeof ChatContentAudioType>;
+/** @internal */
+export declare const ChatContentAudioInputAudio$inboundSchema: z.ZodType<ChatContentAudioInputAudio, unknown>;
+/** @internal */
+export type ChatContentAudioInputAudio$Outbound = {
+    data: string;
+    format: string;
+};
+/** @internal */
+export declare const ChatContentAudioInputAudio$outboundSchema: z.ZodType<ChatContentAudioInputAudio$Outbound, ChatContentAudioInputAudio>;
+export declare function chatContentAudioInputAudioToJSON(chatContentAudioInputAudio: ChatContentAudioInputAudio): string;
+export declare function chatContentAudioInputAudioFromJSON(jsonString: string): SafeParseResult<ChatContentAudioInputAudio, SDKValidationError>;
+/** @internal */
+export declare const ChatContentAudio$inboundSchema: z.ZodType<ChatContentAudio, unknown>;
+/** @internal */
+export type ChatContentAudio$Outbound = {
+    type: string;
+    input_audio: ChatContentAudioInputAudio$Outbound;
+};
+/** @internal */
+export declare const ChatContentAudio$outboundSchema: z.ZodType<ChatContentAudio$Outbound, ChatContentAudio>;
+export declare function chatContentAudioToJSON(chatContentAudio: ChatContentAudio): string;
+export declare function chatContentAudioFromJSON(jsonString: string): SafeParseResult<ChatContentAudio, SDKValidationError>;
+//# sourceMappingURL=chatcontentaudio.d.ts.map

package/esm/models/chatcontentaudio.js

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0f458a760f42
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const ChatContentAudioType = {
+    InputAudio: "input_audio",
+};
+/** @internal */
+export const ChatContentAudioType$inboundSchema = z.enum(ChatContentAudioType);
+/** @internal */
+export const ChatContentAudioType$outboundSchema = ChatContentAudioType$inboundSchema;
+/** @internal */
+export const ChatContentAudioInputAudio$inboundSchema = z.object({
+    data: z.string(),
+    format: z.string(),
+});
+/** @internal */
+export const ChatContentAudioInputAudio$outboundSchema = z.object({
+    data: z.string(),
+    format: z.string(),
+});
+export function chatContentAudioInputAudioToJSON(chatContentAudioInputAudio) {
+    return JSON.stringify(ChatContentAudioInputAudio$outboundSchema.parse(chatContentAudioInputAudio));
+}
+export function chatContentAudioInputAudioFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentAudioInputAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentAudioInputAudio' from JSON`);
+}
+/** @internal */
+export const ChatContentAudio$inboundSchema = z.object({
+    type: ChatContentAudioType$inboundSchema,
+    input_audio: z.lazy(() => ChatContentAudioInputAudio$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "input_audio": "inputAudio",
+    });
+});
+/** @internal */
+export const ChatContentAudio$outboundSchema = z.object({
+    type: ChatContentAudioType$outboundSchema,
+    inputAudio: z.lazy(() => ChatContentAudioInputAudio$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        inputAudio: "input_audio",
+    });
+});
+export function chatContentAudioToJSON(chatContentAudio) {
+    return JSON.stringify(ChatContentAudio$outboundSchema.parse(chatContentAudio));
+}
+export function chatContentAudioFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentAudio' from JSON`);
+}
+//# sourceMappingURL=chatcontentaudio.js.map

package/esm/models/chatcontentcachecontrol.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatContentCacheControlType: {
+    readonly Ephemeral: "ephemeral";
+};
+export type ChatContentCacheControlType = ClosedEnum<typeof ChatContentCacheControlType>;
+export declare const ChatContentCacheControlTtl: {
+    readonly Fivem: "5m";
+    readonly Oneh: "1h";
+};
+export type ChatContentCacheControlTtl = OpenEnum<typeof ChatContentCacheControlTtl>;
+/**
+ * Cache control for the content part
+ */
+export type ChatContentCacheControl = {
+    type: ChatContentCacheControlType;
+    ttl?: ChatContentCacheControlTtl | undefined;
+};
+/** @internal */
+export declare const ChatContentCacheControlType$inboundSchema: z.ZodEnum<typeof ChatContentCacheControlType>;
+/** @internal */
+export declare const ChatContentCacheControlType$outboundSchema: z.ZodEnum<typeof ChatContentCacheControlType>;
+/** @internal */
+export declare const ChatContentCacheControlTtl$inboundSchema: z.ZodType<ChatContentCacheControlTtl, unknown>;
+/** @internal */
+export declare const ChatContentCacheControlTtl$outboundSchema: z.ZodType<string, ChatContentCacheControlTtl>;
+/** @internal */
+export declare const ChatContentCacheControl$inboundSchema: z.ZodType<ChatContentCacheControl, unknown>;
+/** @internal */
+export type ChatContentCacheControl$Outbound = {
+    type: string;
+    ttl?: string | undefined;
+};
+/** @internal */
+export declare const ChatContentCacheControl$outboundSchema: z.ZodType<ChatContentCacheControl$Outbound, ChatContentCacheControl>;
+export declare function chatContentCacheControlToJSON(chatContentCacheControl: ChatContentCacheControl): string;
+export declare function chatContentCacheControlFromJSON(jsonString: string): SafeParseResult<ChatContentCacheControl, SDKValidationError>;
+//# sourceMappingURL=chatcontentcachecontrol.d.ts.map

package/esm/models/chatcontentcachecontrol.js

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2826e2627ca8
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ChatContentCacheControlType = {
+    Ephemeral: "ephemeral",
+};
+export const ChatContentCacheControlTtl = {
+    Fivem: "5m",
+    Oneh: "1h",
+};
+/** @internal */
+export const ChatContentCacheControlType$inboundSchema = z.enum(ChatContentCacheControlType);
+/** @internal */
+export const ChatContentCacheControlType$outboundSchema = ChatContentCacheControlType$inboundSchema;
+/** @internal */
+export const ChatContentCacheControlTtl$inboundSchema = openEnums.inboundSchema(ChatContentCacheControlTtl);
+/** @internal */
+export const ChatContentCacheControlTtl$outboundSchema = openEnums.outboundSchema(ChatContentCacheControlTtl);
+/** @internal */
+export const ChatContentCacheControl$inboundSchema = z.object({
+    type: ChatContentCacheControlType$inboundSchema,
+    ttl: ChatContentCacheControlTtl$inboundSchema.optional(),
+});
+/** @internal */
+export const ChatContentCacheControl$outboundSchema = z.object({
+    type: ChatContentCacheControlType$outboundSchema,
+    ttl: ChatContentCacheControlTtl$outboundSchema.optional(),
+});
+export function chatContentCacheControlToJSON(chatContentCacheControl) {
+    return JSON.stringify(ChatContentCacheControl$outboundSchema.parse(chatContentCacheControl));
+}
+export function chatContentCacheControlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentCacheControl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentCacheControl' from JSON`);
+}
+//# sourceMappingURL=chatcontentcachecontrol.js.map

package/esm/models/{chatmessagecontentitemfile.d.ts → chatcontentfile.d.ts}

@@ -2,10 +2,10 @@ 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 ChatMessageContentItemFileType: {
+export declare const ChatContentFileType: {
     readonly File: "file";
 };
-export type ChatMessageContentItemFileType = ClosedEnum<typeof ChatMessageContentItemFileType>;
+export type ChatContentFileType = ClosedEnum<typeof ChatContentFileType>;
 export type FileT = {
     /**
      * File content as base64 data URL or URL
@@ -23,14 +23,14 @@ export type FileT = {
 /**
  * File content part for document processing
  */
-export type ChatMessageContentItemFile = {
-    type: ChatMessageContentItemFileType;
+export type ChatContentFile = {
+    type: ChatContentFileType;
     file: FileT;
 };
 /** @internal */
-export declare const ChatMessageContentItemFileType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemFileType>;
+export declare const ChatContentFileType$inboundSchema: z.ZodEnum<typeof ChatContentFileType>;
 /** @internal */
-export declare const ChatMessageContentItemFileType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemFileType>;
+export declare const ChatContentFileType$outboundSchema: z.ZodEnum<typeof ChatContentFileType>;
 /** @internal */
 export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
 /** @internal */
@@ -44,14 +44,14 @@ export declare const FileT$outboundSchema: z.ZodType<FileT$Outbound, FileT>;
 export declare function fileToJSON(fileT: FileT): string;
 export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT, SDKValidationError>;
 /** @internal */
-export declare const ChatMessageContentItemFile$inboundSchema: z.ZodType<ChatMessageContentItemFile, unknown>;
+export declare const ChatContentFile$inboundSchema: z.ZodType<ChatContentFile, unknown>;
 /** @internal */
-export type ChatMessageContentItemFile$Outbound = {
+export type ChatContentFile$Outbound = {
     type: string;
     file: FileT$Outbound;
 };
 /** @internal */
-export declare const ChatMessageContentItemFile$outboundSchema: z.ZodType<ChatMessageContentItemFile$Outbound, ChatMessageContentItemFile>;
-export declare function chatMessageContentItemFileToJSON(chatMessageContentItemFile: ChatMessageContentItemFile): string;
-export declare function chatMessageContentItemFileFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemFile, SDKValidationError>;
-//# sourceMappingURL=chatmessagecontentitemfile.d.ts.map
+export declare const ChatContentFile$outboundSchema: z.ZodType<ChatContentFile$Outbound, ChatContentFile>;
+export declare function chatContentFileToJSON(chatContentFile: ChatContentFile): string;
+export declare function chatContentFileFromJSON(jsonString: string): SafeParseResult<ChatContentFile, SDKValidationError>;
+//# sourceMappingURL=chatcontentfile.d.ts.map

package/esm/models/{chatmessagecontentitemfile.js → chatcontentfile.js}

@@ -1,17 +1,17 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: ec73b7087290
+ * @generated-id: ee5054f5da9f
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const ChatMessageContentItemFileType = {
+export const ChatContentFileType = {
     File: "file",
 };
 /** @internal */
-export const ChatMessageContentItemFileType$inboundSchema = z.enum(ChatMessageContentItemFileType);
+export const ChatContentFileType$inboundSchema = z.enum(ChatContentFileType);
 /** @internal */
-export const ChatMessageContentItemFileType$outboundSchema = ChatMessageContentItemFileType$inboundSchema;
+export const ChatContentFileType$outboundSchema = ChatContentFileType$inboundSchema;
 /** @internal */
 export const FileT$inboundSchema = z.object({
     file_data: z.string().optional(),
@@ -41,19 +41,19 @@ export function fileFromJSON(jsonString) {
     return safeParse(jsonString, (x) => FileT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileT' from JSON`);
 }
 /** @internal */
-export const ChatMessageContentItemFile$inboundSchema = z.object({
-    type: ChatMessageContentItemFileType$inboundSchema,
+export const ChatContentFile$inboundSchema = z.object({
+    type: ChatContentFileType$inboundSchema,
     file: z.lazy(() => FileT$inboundSchema),
 });
 /** @internal */
-export const ChatMessageContentItemFile$outboundSchema = z.object({
-    type: ChatMessageContentItemFileType$outboundSchema,
+export const ChatContentFile$outboundSchema = z.object({
+    type: ChatContentFileType$outboundSchema,
     file: z.lazy(() => FileT$outboundSchema),
 });
-export function chatMessageContentItemFileToJSON(chatMessageContentItemFile) {
-    return JSON.stringify(ChatMessageContentItemFile$outboundSchema.parse(chatMessageContentItemFile));
+export function chatContentFileToJSON(chatContentFile) {
+    return JSON.stringify(ChatContentFile$outboundSchema.parse(chatContentFile));
 }
-export function chatMessageContentItemFileFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemFile' from JSON`);
+export function chatContentFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentFile' from JSON`);
 }
-//# sourceMappingURL=chatmessagecontentitemfile.js.map
+//# sourceMappingURL=chatcontentfile.js.map

package/esm/models/chatcontentimage.d.ts

@@ -0,0 +1,68 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatContentImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type ChatContentImageType = ClosedEnum<typeof ChatContentImageType>;
+/**
+ * Image detail level for vision models
+ */
+export declare const ChatContentImageDetail: {
+    readonly Auto: "auto";
+    readonly Low: "low";
+    readonly High: "high";
+};
+/**
+ * Image detail level for vision models
+ */
+export type ChatContentImageDetail = OpenEnum<typeof ChatContentImageDetail>;
+export type ChatContentImageImageUrl = {
+    /**
+     * URL of the image (data: URLs supported)
+     */
+    url: string;
+    /**
+     * Image detail level for vision models
+     */
+    detail?: ChatContentImageDetail | undefined;
+};
+/**
+ * Image content part for vision models
+ */
+export type ChatContentImage = {
+    type: ChatContentImageType;
+    imageUrl: ChatContentImageImageUrl;
+};
+/** @internal */
+export declare const ChatContentImageType$inboundSchema: z.ZodEnum<typeof ChatContentImageType>;
+/** @internal */
+export declare const ChatContentImageType$outboundSchema: z.ZodEnum<typeof ChatContentImageType>;
+/** @internal */
+export declare const ChatContentImageDetail$inboundSchema: z.ZodType<ChatContentImageDetail, unknown>;
+/** @internal */
+export declare const ChatContentImageDetail$outboundSchema: z.ZodType<string, ChatContentImageDetail>;
+/** @internal */
+export declare const ChatContentImageImageUrl$inboundSchema: z.ZodType<ChatContentImageImageUrl, unknown>;
+/** @internal */
+export type ChatContentImageImageUrl$Outbound = {
+    url: string;
+    detail?: string | undefined;
+};
+/** @internal */
+export declare const ChatContentImageImageUrl$outboundSchema: z.ZodType<ChatContentImageImageUrl$Outbound, ChatContentImageImageUrl>;
+export declare function chatContentImageImageUrlToJSON(chatContentImageImageUrl: ChatContentImageImageUrl): string;
+export declare function chatContentImageImageUrlFromJSON(jsonString: string): SafeParseResult<ChatContentImageImageUrl, SDKValidationError>;
+/** @internal */
+export declare const ChatContentImage$inboundSchema: z.ZodType<ChatContentImage, unknown>;
+/** @internal */
+export type ChatContentImage$Outbound = {
+    type: string;
+    image_url: ChatContentImageImageUrl$Outbound;
+};
+/** @internal */
+export declare const ChatContentImage$outboundSchema: z.ZodType<ChatContentImage$Outbound, ChatContentImage>;
+export declare function chatContentImageToJSON(chatContentImage: ChatContentImage): string;
+export declare function chatContentImageFromJSON(jsonString: string): SafeParseResult<ChatContentImage, SDKValidationError>;
+//# sourceMappingURL=chatcontentimage.d.ts.map

package/esm/models/chatcontentimage.js

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0903ebf8f7a0
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ChatContentImageType = {
+    ImageUrl: "image_url",
+};
+/**
+ * Image detail level for vision models
+ */
+export const ChatContentImageDetail = {
+    Auto: "auto",
+    Low: "low",
+    High: "high",
+};
+/** @internal */
+export const ChatContentImageType$inboundSchema = z.enum(ChatContentImageType);
+/** @internal */
+export const ChatContentImageType$outboundSchema = ChatContentImageType$inboundSchema;
+/** @internal */
+export const ChatContentImageDetail$inboundSchema = openEnums.inboundSchema(ChatContentImageDetail);
+/** @internal */
+export const ChatContentImageDetail$outboundSchema = openEnums.outboundSchema(ChatContentImageDetail);
+/** @internal */
+export const ChatContentImageImageUrl$inboundSchema = z.object({
+    url: z.string(),
+    detail: ChatContentImageDetail$inboundSchema.optional(),
+});
+/** @internal */
+export const ChatContentImageImageUrl$outboundSchema = z.object({
+    url: z.string(),
+    detail: ChatContentImageDetail$outboundSchema.optional(),
+});
+export function chatContentImageImageUrlToJSON(chatContentImageImageUrl) {
+    return JSON.stringify(ChatContentImageImageUrl$outboundSchema.parse(chatContentImageImageUrl));
+}
+export function chatContentImageImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentImageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentImageImageUrl' from JSON`);
+}
+/** @internal */
+export const ChatContentImage$inboundSchema = z.object({
+    type: ChatContentImageType$inboundSchema,
+    image_url: z.lazy(() => ChatContentImageImageUrl$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const ChatContentImage$outboundSchema = z.object({
+    type: ChatContentImageType$outboundSchema,
+    imageUrl: z.lazy(() => ChatContentImageImageUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function chatContentImageToJSON(chatContentImage) {
+    return JSON.stringify(ChatContentImage$outboundSchema.parse(chatContentImage));
+}
+export function chatContentImageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentImage' from JSON`);
+}
+//# sourceMappingURL=chatcontentimage.js.map

package/esm/models/chatcontentitems.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatContentAudio, ChatContentAudio$Outbound } from "./chatcontentaudio.js";
+import { ChatContentFile, ChatContentFile$Outbound } from "./chatcontentfile.js";
+import { ChatContentImage, ChatContentImage$Outbound } from "./chatcontentimage.js";
+import { ChatContentText, ChatContentText$Outbound } from "./chatcontenttext.js";
+import { ChatContentVideo, ChatContentVideo$Outbound } from "./chatcontentvideo.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { LegacyChatContentVideo, LegacyChatContentVideo$Outbound } from "./legacychatcontentvideo.js";
+export type ChatContentItems1 = LegacyChatContentVideo | ChatContentVideo;
+/**
+ * Content part for chat completion messages
+ */
+export type ChatContentItems = ChatContentText | ChatContentImage | ChatContentAudio | ChatContentFile | LegacyChatContentVideo | ChatContentVideo;
+/** @internal */
+export declare const ChatContentItems1$inboundSchema: z.ZodType<ChatContentItems1, unknown>;
+/** @internal */
+export type ChatContentItems1$Outbound = LegacyChatContentVideo$Outbound | ChatContentVideo$Outbound;
+/** @internal */
+export declare const ChatContentItems1$outboundSchema: z.ZodType<ChatContentItems1$Outbound, ChatContentItems1>;
+export declare function chatContentItems1ToJSON(chatContentItems1: ChatContentItems1): string;
+export declare function chatContentItems1FromJSON(jsonString: string): SafeParseResult<ChatContentItems1, SDKValidationError>;
+/** @internal */
+export declare const ChatContentItems$inboundSchema: z.ZodType<ChatContentItems, unknown>;
+/** @internal */
+export type ChatContentItems$Outbound = ChatContentText$Outbound | ChatContentImage$Outbound | ChatContentAudio$Outbound | ChatContentFile$Outbound | LegacyChatContentVideo$Outbound | ChatContentVideo$Outbound;
+/** @internal */
+export declare const ChatContentItems$outboundSchema: z.ZodType<ChatContentItems$Outbound, ChatContentItems>;
+export declare function chatContentItemsToJSON(chatContentItems: ChatContentItems): string;
+export declare function chatContentItemsFromJSON(jsonString: string): SafeParseResult<ChatContentItems, SDKValidationError>;
+//# sourceMappingURL=chatcontentitems.d.ts.map

package/esm/models/chatcontentitems.js

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3d8c886d8084
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ChatContentAudio$inboundSchema, ChatContentAudio$outboundSchema, } from "./chatcontentaudio.js";
+import { ChatContentFile$inboundSchema, ChatContentFile$outboundSchema, } from "./chatcontentfile.js";
+import { ChatContentImage$inboundSchema, ChatContentImage$outboundSchema, } from "./chatcontentimage.js";
+import { ChatContentText$inboundSchema, ChatContentText$outboundSchema, } from "./chatcontenttext.js";
+import { ChatContentVideo$inboundSchema, ChatContentVideo$outboundSchema, } from "./chatcontentvideo.js";
+import { LegacyChatContentVideo$inboundSchema, LegacyChatContentVideo$outboundSchema, } from "./legacychatcontentvideo.js";
+/** @internal */
+export const ChatContentItems1$inboundSchema = z.union([
+    LegacyChatContentVideo$inboundSchema,
+    ChatContentVideo$inboundSchema,
+]);
+/** @internal */
+export const ChatContentItems1$outboundSchema = z.union([
+    LegacyChatContentVideo$outboundSchema,
+    ChatContentVideo$outboundSchema,
+]);
+export function chatContentItems1ToJSON(chatContentItems1) {
+    return JSON.stringify(ChatContentItems1$outboundSchema.parse(chatContentItems1));
+}
+export function chatContentItems1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentItems1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentItems1' from JSON`);
+}
+/** @internal */
+export const ChatContentItems$inboundSchema = z.union([
+    ChatContentText$inboundSchema,
+    ChatContentImage$inboundSchema,
+    ChatContentAudio$inboundSchema,
+    ChatContentFile$inboundSchema,
+    z.union([
+        LegacyChatContentVideo$inboundSchema,
+        ChatContentVideo$inboundSchema,
+    ]),
+]);
+/** @internal */
+export const ChatContentItems$outboundSchema = z.union([
+    ChatContentText$outboundSchema,
+    ChatContentImage$outboundSchema,
+    ChatContentAudio$outboundSchema,
+    ChatContentFile$outboundSchema,
+    z.union([
+        LegacyChatContentVideo$outboundSchema,
+        ChatContentVideo$outboundSchema,
+    ]),
+]);
+export function chatContentItemsToJSON(chatContentItems) {
+    return JSON.stringify(ChatContentItems$outboundSchema.parse(chatContentItems));
+}
+export function chatContentItemsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentItems$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentItems' from JSON`);
+}
+//# sourceMappingURL=chatcontentitems.js.map

package/esm/models/chatcontenttext.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatContentCacheControl, ChatContentCacheControl$Outbound } from "./chatcontentcachecontrol.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatContentTextType: {
+    readonly Text: "text";
+};
+export type ChatContentTextType = ClosedEnum<typeof ChatContentTextType>;
+/**
+ * Text content part
+ */
+export type ChatContentText = {
+    type: ChatContentTextType;
+    text: string;
+    /**
+     * Cache control for the content part
+     */
+    cacheControl?: ChatContentCacheControl | undefined;
+};
+/** @internal */
+export declare const ChatContentTextType$inboundSchema: z.ZodEnum<typeof ChatContentTextType>;
+/** @internal */
+export declare const ChatContentTextType$outboundSchema: z.ZodEnum<typeof ChatContentTextType>;
+/** @internal */
+export declare const ChatContentText$inboundSchema: z.ZodType<ChatContentText, unknown>;
+/** @internal */
+export type ChatContentText$Outbound = {
+    type: string;
+    text: string;
+    cache_control?: ChatContentCacheControl$Outbound | undefined;
+};
+/** @internal */
+export declare const ChatContentText$outboundSchema: z.ZodType<ChatContentText$Outbound, ChatContentText>;
+export declare function chatContentTextToJSON(chatContentText: ChatContentText): string;
+export declare function chatContentTextFromJSON(jsonString: string): SafeParseResult<ChatContentText, SDKValidationError>;
+//# sourceMappingURL=chatcontenttext.d.ts.map

package/esm/models/chatcontenttext.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 09b5a48d2bab
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatContentCacheControl$inboundSchema, ChatContentCacheControl$outboundSchema, } from "./chatcontentcachecontrol.js";
+export const ChatContentTextType = {
+    Text: "text",
+};
+/** @internal */
+export const ChatContentTextType$inboundSchema = z.enum(ChatContentTextType);
+/** @internal */
+export const ChatContentTextType$outboundSchema = ChatContentTextType$inboundSchema;
+/** @internal */
+export const ChatContentText$inboundSchema = z.object({
+    type: ChatContentTextType$inboundSchema,
+    text: z.string(),
+    cache_control: ChatContentCacheControl$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "cache_control": "cacheControl",
+    });
+});
+/** @internal */
+export const ChatContentText$outboundSchema = z.object({
+    type: ChatContentTextType$outboundSchema,
+    text: z.string(),
+    cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function chatContentTextToJSON(chatContentText) {
+    return JSON.stringify(ChatContentText$outboundSchema.parse(chatContentText));
+}
+export function chatContentTextFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentText' from JSON`);
+}
+//# sourceMappingURL=chatcontenttext.js.map

package/esm/models/chatcontentvideo.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatContentVideoInput, ChatContentVideoInput$Outbound } from "./chatcontentvideoinput.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Video input content part
+ */
+export type ChatContentVideo = {
+    type: "video_url";
+    /**
+     * Video input object
+     */
+    videoUrl: ChatContentVideoInput;
+};
+/** @internal */
+export declare const ChatContentVideo$inboundSchema: z.ZodType<ChatContentVideo, unknown>;
+/** @internal */
+export type ChatContentVideo$Outbound = {
+    type: "video_url";
+    video_url: ChatContentVideoInput$Outbound;
+};
+/** @internal */
+export declare const ChatContentVideo$outboundSchema: z.ZodType<ChatContentVideo$Outbound, ChatContentVideo>;
+export declare function chatContentVideoToJSON(chatContentVideo: ChatContentVideo): string;
+export declare function chatContentVideoFromJSON(jsonString: string): SafeParseResult<ChatContentVideo, SDKValidationError>;
+//# sourceMappingURL=chatcontentvideo.d.ts.map