@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -1,15 +1,33 @@
 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 ChatMessageContentItemAudioType: {
+    readonly InputAudio: "input_audio";
+};
+export type ChatMessageContentItemAudioType = ClosedEnum<typeof ChatMessageContentItemAudioType>;
 export type ChatMessageContentItemAudioInputAudio = {
+    /**
+     * 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 ChatMessageContentItemAudio = {
-    type: "input_audio";
+    type: ChatMessageContentItemAudioType;
     inputAudio: ChatMessageContentItemAudioInputAudio;
 };
 /** @internal */
+export declare const ChatMessageContentItemAudioType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemAudioType>;
+/** @internal */
+export declare const ChatMessageContentItemAudioType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemAudioType>;
+/** @internal */
 export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudioInputAudio$Outbound = {
@@ -24,7 +42,7 @@ export declare function chatMessageContentItemAudioInputAudioFromJSON(jsonString
 export declare const ChatMessageContentItemAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudio$Outbound = {
-    type: "input_audio";
+    type: string;
     input_audio: ChatMessageContentItemAudioInputAudio$Outbound;
 };
 /** @internal */

package/esm/models/chatmessagecontentitemaudio.js

@@ -5,6 +5,13 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+export const ChatMessageContentItemAudioType = {
+    InputAudio: "input_audio",
+};
+/** @internal */
+export const ChatMessageContentItemAudioType$inboundSchema = z.enum(ChatMessageContentItemAudioType);
+/** @internal */
+export const ChatMessageContentItemAudioType$outboundSchema = ChatMessageContentItemAudioType$inboundSchema;
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
@@ -23,7 +30,7 @@ export function chatMessageContentItemAudioInputAudioFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatMessageContentItemAudio$inboundSchema = z.object({
-    type: z.literal("input_audio"),
+    type: ChatMessageContentItemAudioType$inboundSchema,
     input_audio: z.lazy(() => ChatMessageContentItemAudioInputAudio$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
@@ -32,7 +39,7 @@ export const ChatMessageContentItemAudio$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatMessageContentItemAudio$outboundSchema = z.object({
-    type: z.literal("input_audio"),
+    type: ChatMessageContentItemAudioType$outboundSchema,
     inputAudio: z.lazy(() => ChatMessageContentItemAudioInputAudio$outboundSchema),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatmessagecontentitemcachecontrol.d.ts

@@ -1,25 +1,36 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const Ttl: {
+export declare const ChatMessageContentItemCacheControlType: {
+    readonly Ephemeral: "ephemeral";
+};
+export type ChatMessageContentItemCacheControlType = ClosedEnum<typeof ChatMessageContentItemCacheControlType>;
+export declare const ChatMessageContentItemCacheControlTtl: {
     readonly Fivem: "5m";
     readonly Oneh: "1h";
 };
-export type Ttl = OpenEnum<typeof Ttl>;
+export type ChatMessageContentItemCacheControlTtl = OpenEnum<typeof ChatMessageContentItemCacheControlTtl>;
+/**
+ * Cache control for the content part
+ */
 export type ChatMessageContentItemCacheControl = {
-    type: "ephemeral";
-    ttl?: Ttl | undefined;
+    type: ChatMessageContentItemCacheControlType;
+    ttl?: ChatMessageContentItemCacheControlTtl | undefined;
 };
 /** @internal */
-export declare const Ttl$inboundSchema: z.ZodType<Ttl, unknown>;
+export declare const ChatMessageContentItemCacheControlType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemCacheControlType>;
+/** @internal */
+export declare const ChatMessageContentItemCacheControlType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemCacheControlType>;
+/** @internal */
+export declare const ChatMessageContentItemCacheControlTtl$inboundSchema: z.ZodType<ChatMessageContentItemCacheControlTtl, unknown>;
 /** @internal */
-export declare const Ttl$outboundSchema: z.ZodType<string, Ttl>;
+export declare const ChatMessageContentItemCacheControlTtl$outboundSchema: z.ZodType<string, ChatMessageContentItemCacheControlTtl>;
 /** @internal */
 export declare const ChatMessageContentItemCacheControl$inboundSchema: z.ZodType<ChatMessageContentItemCacheControl, unknown>;
 /** @internal */
 export type ChatMessageContentItemCacheControl$Outbound = {
-    type: "ephemeral";
+    type: string;
     ttl?: string | undefined;
 };
 /** @internal */

package/esm/models/chatmessagecontentitemcachecontrol.js

@@ -5,25 +5,30 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
-export const Ttl = {
+export const ChatMessageContentItemCacheControlType = {
+    Ephemeral: "ephemeral",
+};
+export const ChatMessageContentItemCacheControlTtl = {
     Fivem: "5m",
     Oneh: "1h",
 };
 /** @internal */
-export const Ttl$inboundSchema = openEnums
-    .inboundSchema(Ttl);
+export const ChatMessageContentItemCacheControlType$inboundSchema = z.enum(ChatMessageContentItemCacheControlType);
+/** @internal */
+export const ChatMessageContentItemCacheControlType$outboundSchema = ChatMessageContentItemCacheControlType$inboundSchema;
+/** @internal */
+export const ChatMessageContentItemCacheControlTtl$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemCacheControlTtl);
 /** @internal */
-export const Ttl$outboundSchema = openEnums
-    .outboundSchema(Ttl);
+export const ChatMessageContentItemCacheControlTtl$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemCacheControlTtl);
 /** @internal */
 export const ChatMessageContentItemCacheControl$inboundSchema = z.object({
-    type: z.literal("ephemeral"),
-    ttl: Ttl$inboundSchema.optional(),
+    type: ChatMessageContentItemCacheControlType$inboundSchema,
+    ttl: ChatMessageContentItemCacheControlTtl$inboundSchema.optional(),
 });
 /** @internal */
 export const ChatMessageContentItemCacheControl$outboundSchema = z.object({
-    type: z.literal("ephemeral"),
-    ttl: Ttl$outboundSchema.optional(),
+    type: ChatMessageContentItemCacheControlType$outboundSchema,
+    ttl: ChatMessageContentItemCacheControlTtl$outboundSchema.optional(),
 });
 export function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl) {
     return JSON.stringify(ChatMessageContentItemCacheControl$outboundSchema.parse(chatMessageContentItemCacheControl));

package/esm/models/chatmessagecontentitemfile.d.ts

@@ -0,0 +1,57 @@
+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: {
+    readonly File: "file";
+};
+export type ChatMessageContentItemFileType = ClosedEnum<typeof ChatMessageContentItemFileType>;
+export type FileT = {
+    /**
+     * File content as base64 data URL or URL
+     */
+    fileData?: string | undefined;
+    /**
+     * File ID for previously uploaded files
+     */
+    fileId?: string | undefined;
+    /**
+     * Original filename
+     */
+    filename?: string | undefined;
+};
+/**
+ * File content part for document processing
+ */
+export type ChatMessageContentItemFile = {
+    type: ChatMessageContentItemFileType;
+    file: FileT;
+};
+/** @internal */
+export declare const ChatMessageContentItemFileType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemFileType>;
+/** @internal */
+export declare const ChatMessageContentItemFileType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemFileType>;
+/** @internal */
+export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
+/** @internal */
+export type FileT$Outbound = {
+    file_data?: string | undefined;
+    file_id?: string | undefined;
+    filename?: string | undefined;
+};
+/** @internal */
+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>;
+/** @internal */
+export type ChatMessageContentItemFile$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

package/esm/models/chatmessagecontentitemfile.js

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ec73b7087290
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const ChatMessageContentItemFileType = {
+    File: "file",
+};
+/** @internal */
+export const ChatMessageContentItemFileType$inboundSchema = z.enum(ChatMessageContentItemFileType);
+/** @internal */
+export const ChatMessageContentItemFileType$outboundSchema = ChatMessageContentItemFileType$inboundSchema;
+/** @internal */
+export const FileT$inboundSchema = z.object({
+    file_data: z.string().optional(),
+    file_id: z.string().optional(),
+    filename: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "file_data": "fileData",
+        "file_id": "fileId",
+    });
+});
+/** @internal */
+export const FileT$outboundSchema = z.object({
+    fileData: z.string().optional(),
+    fileId: z.string().optional(),
+    filename: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        fileData: "file_data",
+        fileId: "file_id",
+    });
+});
+export function fileToJSON(fileT) {
+    return JSON.stringify(FileT$outboundSchema.parse(fileT));
+}
+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,
+    file: z.lazy(() => FileT$inboundSchema),
+});
+/** @internal */
+export const ChatMessageContentItemFile$outboundSchema = z.object({
+    type: ChatMessageContentItemFileType$outboundSchema,
+    file: z.lazy(() => FileT$outboundSchema),
+});
+export function chatMessageContentItemFileToJSON(chatMessageContentItemFile) {
+    return JSON.stringify(ChatMessageContentItemFile$outboundSchema.parse(chatMessageContentItemFile));
+}
+export function chatMessageContentItemFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemFile' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemfile.js.map

package/esm/models/chatmessagecontentitemimage.d.ts

@@ -1,22 +1,45 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatMessageContentItemImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type ChatMessageContentItemImageType = ClosedEnum<typeof ChatMessageContentItemImageType>;
+/**
+ * Image detail level for vision models
+ */
 export declare const ChatMessageContentItemImageDetail: {
     readonly Auto: "auto";
     readonly Low: "low";
     readonly High: "high";
 };
+/**
+ * Image detail level for vision models
+ */
 export type ChatMessageContentItemImageDetail = OpenEnum<typeof ChatMessageContentItemImageDetail>;
 export type ChatMessageContentItemImageImageUrl = {
+    /**
+     * URL of the image (data: URLs supported)
+     */
     url: string;
+    /**
+     * Image detail level for vision models
+     */
     detail?: ChatMessageContentItemImageDetail | undefined;
 };
+/**
+ * Image content part for vision models
+ */
 export type ChatMessageContentItemImage = {
-    type: "image_url";
+    type: ChatMessageContentItemImageType;
     imageUrl: ChatMessageContentItemImageImageUrl;
 };
 /** @internal */
+export declare const ChatMessageContentItemImageType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemImageType>;
+/** @internal */
+export declare const ChatMessageContentItemImageType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemImageType>;
+/** @internal */
 export declare const ChatMessageContentItemImageDetail$inboundSchema: z.ZodType<ChatMessageContentItemImageDetail, unknown>;
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<string, ChatMessageContentItemImageDetail>;
@@ -35,7 +58,7 @@ export declare function chatMessageContentItemImageImageUrlFromJSON(jsonString:
 export declare const ChatMessageContentItemImage$inboundSchema: z.ZodType<ChatMessageContentItemImage, unknown>;
 /** @internal */
 export type ChatMessageContentItemImage$Outbound = {
-    type: "image_url";
+    type: string;
     image_url: ChatMessageContentItemImageImageUrl$Outbound;
 };
 /** @internal */

package/esm/models/chatmessagecontentitemimage.js

@@ -6,12 +6,22 @@ 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 ChatMessageContentItemImageType = {
+    ImageUrl: "image_url",
+};
+/**
+ * Image detail level for vision models
+ */
 export const ChatMessageContentItemImageDetail = {
     Auto: "auto",
     Low: "low",
     High: "high",
 };
 /** @internal */
+export const ChatMessageContentItemImageType$inboundSchema = z.enum(ChatMessageContentItemImageType);
+/** @internal */
+export const ChatMessageContentItemImageType$outboundSchema = ChatMessageContentItemImageType$inboundSchema;
+/** @internal */
 export const ChatMessageContentItemImageDetail$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemImageDetail);
 /** @internal */
 export const ChatMessageContentItemImageDetail$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemImageDetail);
@@ -33,7 +43,7 @@ export function chatMessageContentItemImageImageUrlFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatMessageContentItemImage$inboundSchema = z.object({
-    type: z.literal("image_url"),
+    type: ChatMessageContentItemImageType$inboundSchema,
     image_url: z.lazy(() => ChatMessageContentItemImageImageUrl$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
@@ -42,7 +52,7 @@ export const ChatMessageContentItemImage$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatMessageContentItemImage$outboundSchema = z.object({
-    type: z.literal("image_url"),
+    type: ChatMessageContentItemImageType$outboundSchema,
     imageUrl: z.lazy(() => ChatMessageContentItemImageImageUrl$outboundSchema),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatmessagecontentitemtext.d.ts

@@ -1,17 +1,32 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageContentItemCacheControl, ChatMessageContentItemCacheControl$Outbound } from "./chatmessagecontentitemcachecontrol.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatMessageContentItemTextType: {
+    readonly Text: "text";
+};
+export type ChatMessageContentItemTextType = ClosedEnum<typeof ChatMessageContentItemTextType>;
+/**
+ * Text content part
+ */
 export type ChatMessageContentItemText = {
-    type: "text";
+    type: ChatMessageContentItemTextType;
     text: string;
+    /**
+     * Cache control for the content part
+     */
     cacheControl?: ChatMessageContentItemCacheControl | undefined;
 };
 /** @internal */
+export declare const ChatMessageContentItemTextType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemTextType>;
+/** @internal */
+export declare const ChatMessageContentItemTextType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemTextType>;
+/** @internal */
 export declare const ChatMessageContentItemText$inboundSchema: z.ZodType<ChatMessageContentItemText, unknown>;
 /** @internal */
 export type ChatMessageContentItemText$Outbound = {
-    type: "text";
+    type: string;
     text: string;
     cache_control?: ChatMessageContentItemCacheControl$Outbound | undefined;
 };

package/esm/models/chatmessagecontentitemtext.js

@@ -6,9 +6,16 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatMessageContentItemCacheControl$inboundSchema, ChatMessageContentItemCacheControl$outboundSchema, } from "./chatmessagecontentitemcachecontrol.js";
+export const ChatMessageContentItemTextType = {
+    Text: "text",
+};
+/** @internal */
+export const ChatMessageContentItemTextType$inboundSchema = z.enum(ChatMessageContentItemTextType);
+/** @internal */
+export const ChatMessageContentItemTextType$outboundSchema = ChatMessageContentItemTextType$inboundSchema;
 /** @internal */
 export const ChatMessageContentItemText$inboundSchema = z.object({
-    type: z.literal("text"),
+    type: ChatMessageContentItemTextType$inboundSchema,
     text: z.string(),
     cache_control: ChatMessageContentItemCacheControl$inboundSchema.optional(),
 }).transform((v) => {
@@ -18,7 +25,7 @@ export const ChatMessageContentItemText$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatMessageContentItemText$outboundSchema = z.object({
-    type: z.literal("text"),
+    type: ChatMessageContentItemTextType$outboundSchema,
     text: z.string(),
     cacheControl: ChatMessageContentItemCacheControl$outboundSchema.optional(),
 }).transform((v) => {

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,68 +1,25 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoUrl2 = {
-    url: string;
-};
-export type ChatMessageContentItemVideoVideoURL = {
+import { VideoInput, VideoInput$Outbound } from "./videoinput.js";
+/**
+ * Video input content part
+ */
+export type ChatMessageContentItemVideo = {
     type: "video_url";
-    videoUrl: VideoUrl2;
-};
-export type VideoUrl1 = {
-    url: string;
-};
-export type ChatMessageContentItemVideoInputVideo = {
-    type: "input_video";
-    videoUrl: VideoUrl1;
-};
-export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
-/** @internal */
-export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
-/** @internal */
-export type VideoUrl2$Outbound = {
-    url: string;
+    /**
+     * Video input object
+     */
+    videoUrl: VideoInput;
 };
 /** @internal */
-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 ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
+export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
 /** @internal */
-export type ChatMessageContentItemVideoVideoURL$Outbound = {
+export type ChatMessageContentItemVideo$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: VideoUrl1$Outbound;
+    video_url: VideoInput$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,92 +5,25 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { VideoInput$inboundSchema, VideoInput$outboundSchema, } from "./videoinput.js";
 /** @internal */
-export const VideoUrl2$inboundSchema = z.object({
-    url: z.string(),
-});
-/** @internal */
-export const VideoUrl2$outboundSchema = z.object({
-    url: z.string(),
-});
-export function videoUrl2ToJSON(videoUrl2) {
-    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
-}
-export function videoUrl2FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoUrl2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl2' from JSON`);
-}
-/** @internal */
-export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
+export const ChatMessageContentItemVideo$inboundSchema = z.object({
     type: z.literal("video_url"),
-    video_url: z.lazy(() => VideoUrl2$inboundSchema),
+    video_url: VideoInput$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
     });
 });
 /** @internal */
-export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
+export const ChatMessageContentItemVideo$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(() => VideoUrl1$inboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        "video_url": "videoUrl",
-    });
-});
-/** @internal */
-export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
-    type: z.literal("input_video"),
-    videoUrl: z.lazy(() => VideoUrl1$outboundSchema),
+    videoUrl: VideoInput$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/chatmessagecontentitemvideolegacy.d.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { VideoInput, VideoInput$Outbound } from "./videoinput.js";
+/**
+ * Video input content part (legacy format - deprecated)
+ *
+ * @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
+ */
+export type ChatMessageContentItemVideoLegacy = {
+    type: "input_video";
+    /**
+     * Video input object
+     */
+    videoUrl: VideoInput;
+};
+/** @internal */
+export declare const ChatMessageContentItemVideoLegacy$inboundSchema: z.ZodType<ChatMessageContentItemVideoLegacy, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideoLegacy$Outbound = {
+    type: "input_video";
+    video_url: VideoInput$Outbound;
+};
+/** @internal */
+export declare const ChatMessageContentItemVideoLegacy$outboundSchema: z.ZodType<ChatMessageContentItemVideoLegacy$Outbound, ChatMessageContentItemVideoLegacy>;
+export declare function chatMessageContentItemVideoLegacyToJSON(chatMessageContentItemVideoLegacy: ChatMessageContentItemVideoLegacy): string;
+export declare function chatMessageContentItemVideoLegacyFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoLegacy, SDKValidationError>;
+//# sourceMappingURL=chatmessagecontentitemvideolegacy.d.ts.map