@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/chatassistantmessage.d.ts

@@ -7,35 +7,34 @@ import { ChatContentItems, ChatContentItems$Outbound } from "./chatcontentitems.
 import { ChatToolCall, ChatToolCall$Outbound } from "./chattoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ReasoningDetailUnion, ReasoningDetailUnion$Outbound } from "./reasoningdetailunion.js";
-export declare const ChatAssistantMessageRole: {
-    readonly Assistant: "assistant";
-};
-export type ChatAssistantMessageRole = ClosedEnum<typeof ChatAssistantMessageRole>;
 /**
  * Assistant message content
  */
 export type ChatAssistantMessageContent = string | Array<ChatContentItems> | any;
+export declare const ChatAssistantMessageRole: {
+    readonly Assistant: "assistant";
+};
+export type ChatAssistantMessageRole = ClosedEnum<typeof ChatAssistantMessageRole>;
 /**
  * Assistant message for requests and responses
  */
 export type ChatAssistantMessage = {
-    role: ChatAssistantMessageRole;
     /**
-     * Assistant message content
+     * Audio output data or reference
      */
-    content?: string | Array<ChatContentItems> | any | null | undefined;
+    audio?: ChatAudioOutput | undefined;
     /**
-     * Optional name for the assistant
+     * Assistant message content
      */
-    name?: string | undefined;
+    content?: string | Array<ChatContentItems> | any | null | undefined;
     /**
-     * Tool calls made by the assistant
+     * Generated images from image generation models
      */
-    toolCalls?: Array<ChatToolCall> | undefined;
+    images?: Array<ChatAssistantImages> | undefined;
     /**
-     * Refusal message if content was refused
+     * Optional name for the assistant
      */
-    refusal?: string | null | undefined;
+    name?: string | undefined;
     /**
      * Reasoning output
      */
@@ -45,19 +44,16 @@ export type ChatAssistantMessage = {
      */
     reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
     /**
-     * Generated images from image generation models
+     * Refusal message if content was refused
      */
-    images?: Array<ChatAssistantImages> | undefined;
+    refusal?: string | null | undefined;
+    role: ChatAssistantMessageRole;
     /**
-     * Audio output data or reference
+     * Tool calls made by the assistant
      */
-    audio?: ChatAudioOutput | undefined;
+    toolCalls?: Array<ChatToolCall> | undefined;
 };
 /** @internal */
-export declare const ChatAssistantMessageRole$inboundSchema: z.ZodEnum<typeof ChatAssistantMessageRole>;
-/** @internal */
-export declare const ChatAssistantMessageRole$outboundSchema: z.ZodEnum<typeof ChatAssistantMessageRole>;
-/** @internal */
 export declare const ChatAssistantMessageContent$inboundSchema: z.ZodType<ChatAssistantMessageContent, unknown>;
 /** @internal */
 export type ChatAssistantMessageContent$Outbound = string | Array<ChatContentItems$Outbound> | any;
@@ -66,18 +62,22 @@ export declare const ChatAssistantMessageContent$outboundSchema: z.ZodType<ChatA
 export declare function chatAssistantMessageContentToJSON(chatAssistantMessageContent: ChatAssistantMessageContent): string;
 export declare function chatAssistantMessageContentFromJSON(jsonString: string): SafeParseResult<ChatAssistantMessageContent, SDKValidationError>;
 /** @internal */
+export declare const ChatAssistantMessageRole$inboundSchema: z.ZodEnum<typeof ChatAssistantMessageRole>;
+/** @internal */
+export declare const ChatAssistantMessageRole$outboundSchema: z.ZodEnum<typeof ChatAssistantMessageRole>;
+/** @internal */
 export declare const ChatAssistantMessage$inboundSchema: z.ZodType<ChatAssistantMessage, unknown>;
 /** @internal */
 export type ChatAssistantMessage$Outbound = {
-    role: string;
+    audio?: ChatAudioOutput$Outbound | undefined;
     content?: string | Array<ChatContentItems$Outbound> | any | null | undefined;
+    images?: Array<ChatAssistantImages$Outbound> | undefined;
     name?: string | undefined;
-    tool_calls?: Array<ChatToolCall$Outbound> | undefined;
-    refusal?: string | null | undefined;
     reasoning?: string | null | undefined;
     reasoning_details?: Array<ReasoningDetailUnion$Outbound> | undefined;
-    images?: Array<ChatAssistantImages$Outbound> | undefined;
-    audio?: ChatAudioOutput$Outbound | undefined;
+    refusal?: string | null | undefined;
+    role: string;
+    tool_calls?: Array<ChatToolCall$Outbound> | undefined;
 };
 /** @internal */
 export declare const ChatAssistantMessage$outboundSchema: z.ZodType<ChatAssistantMessage$Outbound, ChatAssistantMessage>;

package/esm/models/chatassistantmessage.js

@@ -14,10 +14,6 @@ export const ChatAssistantMessageRole = {
     Assistant: "assistant",
 };
 /** @internal */
-export const ChatAssistantMessageRole$inboundSchema = z.enum(ChatAssistantMessageRole);
-/** @internal */
-export const ChatAssistantMessageRole$outboundSchema = ChatAssistantMessageRole$inboundSchema;
-/** @internal */
 export const ChatAssistantMessageContent$inboundSchema = z.union([z.string(), z.array(ChatContentItems$inboundSchema), z.any()]);
 /** @internal */
 export const ChatAssistantMessageContent$outboundSchema = z.union([z.string(), z.array(ChatContentItems$outboundSchema), z.any()]);
@@ -28,37 +24,41 @@ export function chatAssistantMessageContentFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatAssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatAssistantMessageContent' from JSON`);
 }
 /** @internal */
+export const ChatAssistantMessageRole$inboundSchema = z.enum(ChatAssistantMessageRole);
+/** @internal */
+export const ChatAssistantMessageRole$outboundSchema = ChatAssistantMessageRole$inboundSchema;
+/** @internal */
 export const ChatAssistantMessage$inboundSchema = z.object({
-    role: ChatAssistantMessageRole$inboundSchema,
+    audio: ChatAudioOutput$inboundSchema.optional(),
     content: z.nullable(z.union([z.string(), z.array(ChatContentItems$inboundSchema), z.any()])).optional(),
+    images: z.array(ChatAssistantImages$inboundSchema).optional(),
     name: z.string().optional(),
-    tool_calls: z.array(ChatToolCall$inboundSchema).optional(),
-    refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
     reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
-    images: z.array(ChatAssistantImages$inboundSchema).optional(),
-    audio: ChatAudioOutput$inboundSchema.optional(),
+    refusal: z.nullable(z.string()).optional(),
+    role: ChatAssistantMessageRole$inboundSchema,
+    tool_calls: z.array(ChatToolCall$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
-        "tool_calls": "toolCalls",
         "reasoning_details": "reasoningDetails",
+        "tool_calls": "toolCalls",
     });
 });
 /** @internal */
 export const ChatAssistantMessage$outboundSchema = z.object({
-    role: ChatAssistantMessageRole$outboundSchema,
+    audio: ChatAudioOutput$outboundSchema.optional(),
     content: z.nullable(z.union([z.string(), z.array(ChatContentItems$outboundSchema), z.any()])).optional(),
+    images: z.array(ChatAssistantImages$outboundSchema).optional(),
     name: z.string().optional(),
-    toolCalls: z.array(ChatToolCall$outboundSchema).optional(),
-    refusal: z.nullable(z.string()).optional(),
     reasoning: z.nullable(z.string()).optional(),
     reasoningDetails: z.array(ReasoningDetailUnion$outboundSchema).optional(),
-    images: z.array(ChatAssistantImages$outboundSchema).optional(),
-    audio: ChatAudioOutput$outboundSchema.optional(),
+    refusal: z.nullable(z.string()).optional(),
+    role: ChatAssistantMessageRole$outboundSchema,
+    toolCalls: z.array(ChatToolCall$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
-        toolCalls: "tool_calls",
         reasoningDetails: "reasoning_details",
+        toolCalls: "tool_calls",
     });
 });
 export function chatAssistantMessageToJSON(chatAssistantMessage) {

package/esm/models/chataudiooutput.d.ts

@@ -6,17 +6,17 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export type ChatAudioOutput = {
     /**
-     * Audio output identifier
+     * Base64 encoded audio data
      */
-    id?: string | undefined;
+    data?: string | undefined;
     /**
      * Audio expiration timestamp
      */
     expiresAt?: number | undefined;
     /**
-     * Base64 encoded audio data
+     * Audio output identifier
      */
-    data?: string | undefined;
+    id?: string | undefined;
     /**
      * Audio transcript
      */
@@ -26,9 +26,9 @@ export type ChatAudioOutput = {
 export declare const ChatAudioOutput$inboundSchema: z.ZodType<ChatAudioOutput, unknown>;
 /** @internal */
 export type ChatAudioOutput$Outbound = {
-    id?: string | undefined;
-    expires_at?: number | undefined;
     data?: string | undefined;
+    expires_at?: number | undefined;
+    id?: string | undefined;
     transcript?: string | undefined;
 };
 /** @internal */

package/esm/models/chataudiooutput.js

@@ -7,9 +7,9 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ChatAudioOutput$inboundSchema = z.object({
-    id: z.string().optional(),
-    expires_at: z.number().optional(),
     data: z.string().optional(),
+    expires_at: z.int().optional(),
+    id: z.string().optional(),
     transcript: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -18,9 +18,9 @@ export const ChatAudioOutput$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatAudioOutput$outboundSchema = z.object({
-    id: z.string().optional(),
-    expiresAt: z.number().optional(),
     data: z.string().optional(),
+    expiresAt: z.int().optional(),
+    id: z.string().optional(),
     transcript: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatchoice.d.ts

@@ -1,25 +1,26 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatAssistantMessage } from "./chatassistantmessage.js";
+import { ChatFinishReasonEnum } from "./chatfinishreasonenum.js";
 import { ChatTokenLogprobs } from "./chattokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Chat completion choice
  */
 export type ChatChoice = {
-    finishReason: any | null;
+    finishReason: ChatFinishReasonEnum | null;
     /**
      * Choice index
      */
     index: number;
-    /**
-     * Assistant message for requests and responses
-     */
-    message: ChatAssistantMessage;
     /**
      * Log probabilities for the completion
      */
     logprobs?: ChatTokenLogprobs | null | undefined;
+    /**
+     * Assistant message for requests and responses
+     */
+    message: ChatAssistantMessage;
 };
 /** @internal */
 export declare const ChatChoice$inboundSchema: z.ZodType<ChatChoice, unknown>;

package/esm/models/chatchoice.js

@@ -6,14 +6,15 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatAssistantMessage$inboundSchema, } from "./chatassistantmessage.js";
+import { ChatFinishReasonEnum$inboundSchema, } from "./chatfinishreasonenum.js";
 import { ChatTokenLogprobs$inboundSchema, } from "./chattokenlogprobs.js";
 /** @internal */
 export const ChatChoice$inboundSchema = z
     .object({
-    finish_reason: z.nullable(z.any()),
-    index: z.number(),
-    message: ChatAssistantMessage$inboundSchema,
+    finish_reason: z.nullable(ChatFinishReasonEnum$inboundSchema),
+    index: z.int(),
     logprobs: z.nullable(ChatTokenLogprobs$inboundSchema).optional(),
+    message: ChatAssistantMessage$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "finish_reason": "finishReason",

package/esm/models/chatcontentaudio.d.ts

@@ -1,11 +1,6 @@
 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
@@ -20,14 +15,10 @@ export type ChatContentAudioInputAudio = {
  * Audio input content part. Supported audio formats vary by provider.
  */
 export type ChatContentAudio = {
-    type: ChatContentAudioType;
     inputAudio: ChatContentAudioInputAudio;
+    type: "input_audio";
 };
 /** @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 = {
@@ -42,8 +33,8 @@ export declare function chatContentAudioInputAudioFromJSON(jsonString: string):
 export declare const ChatContentAudio$inboundSchema: z.ZodType<ChatContentAudio, unknown>;
 /** @internal */
 export type ChatContentAudio$Outbound = {
-    type: string;
     input_audio: ChatContentAudioInputAudio$Outbound;
+    type: "input_audio";
 };
 /** @internal */
 export declare const ChatContentAudio$outboundSchema: z.ZodType<ChatContentAudio$Outbound, ChatContentAudio>;

package/esm/models/chatcontentaudio.js

@@ -5,13 +5,6 @@
 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(),
@@ -30,8 +23,8 @@ export function chatContentAudioInputAudioFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatContentAudio$inboundSchema = z.object({
-    type: ChatContentAudioType$inboundSchema,
     input_audio: z.lazy(() => ChatContentAudioInputAudio$inboundSchema),
+    type: z.literal("input_audio"),
 }).transform((v) => {
     return remap$(v, {
         "input_audio": "inputAudio",
@@ -39,8 +32,8 @@ export const ChatContentAudio$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatContentAudio$outboundSchema = z.object({
-    type: ChatContentAudioType$outboundSchema,
     inputAudio: z.lazy(() => ChatContentAudioInputAudio$outboundSchema),
+    type: z.literal("input_audio"),
 }).transform((v) => {
     return remap$(v, {
         inputAudio: "input_audio",

package/esm/models/chatcontentcachecontrol.d.ts

@@ -1,37 +1,29 @@
 import * as z from "zod/v4";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCacheControlTtl } from "./anthropiccachecontrolttl.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 = {
+    ttl?: AnthropicCacheControlTtl | undefined;
     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;
+    type: string;
 };
 /** @internal */
 export declare const ChatContentCacheControl$outboundSchema: z.ZodType<ChatContentCacheControl$Outbound, ChatContentCacheControl>;

package/esm/models/chatcontentcachecontrol.js

@@ -4,31 +4,23 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
+import { AnthropicCacheControlTtl$inboundSchema, AnthropicCacheControlTtl$outboundSchema, } from "./anthropiccachecontrolttl.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({
+    ttl: AnthropicCacheControlTtl$inboundSchema.optional(),
     type: ChatContentCacheControlType$inboundSchema,
-    ttl: ChatContentCacheControlTtl$inboundSchema.optional(),
 });
 /** @internal */
 export const ChatContentCacheControl$outboundSchema = z.object({
+    ttl: AnthropicCacheControlTtl$outboundSchema.optional(),
     type: ChatContentCacheControlType$outboundSchema,
-    ttl: ChatContentCacheControlTtl$outboundSchema.optional(),
 });
 export function chatContentCacheControlToJSON(chatContentCacheControl) {
     return JSON.stringify(ChatContentCacheControl$outboundSchema.parse(chatContentCacheControl));

package/esm/models/chatcontentfile.d.ts

@@ -1,11 +1,6 @@
 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 ChatContentFileType: {
-    readonly File: "file";
-};
-export type ChatContentFileType = ClosedEnum<typeof ChatContentFileType>;
 export type FileT = {
     /**
      * File content as base64 data URL or URL
@@ -24,14 +19,10 @@ export type FileT = {
  * File content part for document processing
  */
 export type ChatContentFile = {
-    type: ChatContentFileType;
     file: FileT;
+    type: "file";
 };
 /** @internal */
-export declare const ChatContentFileType$inboundSchema: z.ZodEnum<typeof ChatContentFileType>;
-/** @internal */
-export declare const ChatContentFileType$outboundSchema: z.ZodEnum<typeof ChatContentFileType>;
-/** @internal */
 export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
 /** @internal */
 export type FileT$Outbound = {
@@ -47,8 +38,8 @@ export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT,
 export declare const ChatContentFile$inboundSchema: z.ZodType<ChatContentFile, unknown>;
 /** @internal */
 export type ChatContentFile$Outbound = {
-    type: string;
     file: FileT$Outbound;
+    type: "file";
 };
 /** @internal */
 export declare const ChatContentFile$outboundSchema: z.ZodType<ChatContentFile$Outbound, ChatContentFile>;

package/esm/models/chatcontentfile.js

@@ -5,13 +5,6 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const ChatContentFileType = {
-    File: "file",
-};
-/** @internal */
-export const ChatContentFileType$inboundSchema = z.enum(ChatContentFileType);
-/** @internal */
-export const ChatContentFileType$outboundSchema = ChatContentFileType$inboundSchema;
 /** @internal */
 export const FileT$inboundSchema = z.object({
     file_data: z.string().optional(),
@@ -42,13 +35,13 @@ export function fileFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatContentFile$inboundSchema = z.object({
-    type: ChatContentFileType$inboundSchema,
     file: z.lazy(() => FileT$inboundSchema),
+    type: z.literal("file"),
 });
 /** @internal */
 export const ChatContentFile$outboundSchema = z.object({
-    type: ChatContentFileType$outboundSchema,
     file: z.lazy(() => FileT$outboundSchema),
+    type: z.literal("file"),
 });
 export function chatContentFileToJSON(chatContentFile) {
     return JSON.stringify(ChatContentFile$outboundSchema.parse(chatContentFile));

package/esm/models/chatcontentimage.d.ts

@@ -1,11 +1,7 @@
 import * as z from "zod/v4";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { 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
  */
@@ -19,27 +15,23 @@ export declare const ChatContentImageDetail: {
  */
 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;
+    /**
+     * URL of the image (data: URLs supported)
+     */
+    url: string;
 };
 /**
  * Image content part for vision models
  */
 export type ChatContentImage = {
-    type: ChatContentImageType;
     imageUrl: ChatContentImageImageUrl;
+    type: "image_url";
 };
 /** @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>;
@@ -47,8 +39,8 @@ export declare const ChatContentImageDetail$outboundSchema: z.ZodType<string, Ch
 export declare const ChatContentImageImageUrl$inboundSchema: z.ZodType<ChatContentImageImageUrl, unknown>;
 /** @internal */
 export type ChatContentImageImageUrl$Outbound = {
-    url: string;
     detail?: string | undefined;
+    url: string;
 };
 /** @internal */
 export declare const ChatContentImageImageUrl$outboundSchema: z.ZodType<ChatContentImageImageUrl$Outbound, ChatContentImageImageUrl>;
@@ -58,8 +50,8 @@ export declare function chatContentImageImageUrlFromJSON(jsonString: string): Sa
 export declare const ChatContentImage$inboundSchema: z.ZodType<ChatContentImage, unknown>;
 /** @internal */
 export type ChatContentImage$Outbound = {
-    type: string;
     image_url: ChatContentImageImageUrl$Outbound;
+    type: "image_url";
 };
 /** @internal */
 export declare const ChatContentImage$outboundSchema: z.ZodType<ChatContentImage$Outbound, ChatContentImage>;

package/esm/models/chatcontentimage.js

@@ -6,9 +6,6 @@ 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
  */
@@ -18,22 +15,18 @@ export const ChatContentImageDetail = {
     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(),
+    url: z.string(),
 });
 /** @internal */
 export const ChatContentImageImageUrl$outboundSchema = z.object({
-    url: z.string(),
     detail: ChatContentImageDetail$outboundSchema.optional(),
+    url: z.string(),
 });
 export function chatContentImageImageUrlToJSON(chatContentImageImageUrl) {
     return JSON.stringify(ChatContentImageImageUrl$outboundSchema.parse(chatContentImageImageUrl));
@@ -43,8 +36,8 @@ export function chatContentImageImageUrlFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatContentImage$inboundSchema = z.object({
-    type: ChatContentImageType$inboundSchema,
     image_url: z.lazy(() => ChatContentImageImageUrl$inboundSchema),
+    type: z.literal("image_url"),
 }).transform((v) => {
     return remap$(v, {
         "image_url": "imageUrl",
@@ -52,8 +45,8 @@ export const ChatContentImage$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatContentImage$outboundSchema = z.object({
-    type: ChatContentImageType$outboundSchema,
     imageUrl: z.lazy(() => ChatContentImageImageUrl$outboundSchema),
+    type: z.literal("image_url"),
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",

package/esm/models/chatcontentitems.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 { ChatContentAudio, ChatContentAudio$Outbound } from "./chatcontentaudio.js";
 import { ChatContentFile, ChatContentFile$Outbound } from "./chatcontentfile.js";
@@ -7,23 +8,18 @@ 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>;
+export type ChatContentItems = ChatContentFile | ChatContentImage | ChatContentAudio | LegacyChatContentVideo | (ChatContentText & {
+    type: "text";
+}) | ChatContentVideo | discriminatedUnionTypes.Unknown<"type">;
 /** @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;
+export type ChatContentItems$Outbound = ChatContentFile$Outbound | ChatContentImage$Outbound | ChatContentAudio$Outbound | LegacyChatContentVideo$Outbound | (ChatContentText$Outbound & {
+    type: "text";
+}) | ChatContentVideo$Outbound;
 /** @internal */
 export declare const ChatContentItems$outboundSchema: z.ZodType<ChatContentItems$Outbound, ChatContentItems>;
 export declare function chatContentItemsToJSON(chatContentItems: ChatContentItems): string;