@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/chatassistantmessage.d.ts

@@ -0,0 +1,86 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatAssistantImages, ChatAssistantImages$Outbound } from "./chatassistantimages.js";
+import { ChatAudioOutput, ChatAudioOutput$Outbound } from "./chataudiooutput.js";
+import { ChatContentItems, ChatContentItems$Outbound } from "./chatcontentitems.js";
+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;
+/**
+ * Assistant message for requests and responses
+ */
+export type ChatAssistantMessage = {
+    role: ChatAssistantMessageRole;
+    /**
+     * Assistant message content
+     */
+    content?: string | Array<ChatContentItems> | any | null | undefined;
+    /**
+     * Optional name for the assistant
+     */
+    name?: string | undefined;
+    /**
+     * Tool calls made by the assistant
+     */
+    toolCalls?: Array<ChatToolCall> | undefined;
+    /**
+     * Refusal message if content was refused
+     */
+    refusal?: string | null | undefined;
+    /**
+     * Reasoning output
+     */
+    reasoning?: string | null | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
+    /**
+     * Generated images from image generation models
+     */
+    images?: Array<ChatAssistantImages> | undefined;
+    /**
+     * Audio output data or reference
+     */
+    audio?: ChatAudioOutput | 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;
+/** @internal */
+export declare const ChatAssistantMessageContent$outboundSchema: z.ZodType<ChatAssistantMessageContent$Outbound, ChatAssistantMessageContent>;
+export declare function chatAssistantMessageContentToJSON(chatAssistantMessageContent: ChatAssistantMessageContent): string;
+export declare function chatAssistantMessageContentFromJSON(jsonString: string): SafeParseResult<ChatAssistantMessageContent, SDKValidationError>;
+/** @internal */
+export declare const ChatAssistantMessage$inboundSchema: z.ZodType<ChatAssistantMessage, unknown>;
+/** @internal */
+export type ChatAssistantMessage$Outbound = {
+    role: string;
+    content?: string | Array<ChatContentItems$Outbound> | any | null | 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;
+};
+/** @internal */
+export declare const ChatAssistantMessage$outboundSchema: z.ZodType<ChatAssistantMessage$Outbound, ChatAssistantMessage>;
+export declare function chatAssistantMessageToJSON(chatAssistantMessage: ChatAssistantMessage): string;
+export declare function chatAssistantMessageFromJSON(jsonString: string): SafeParseResult<ChatAssistantMessage, SDKValidationError>;
+//# sourceMappingURL=chatassistantmessage.d.ts.map

package/esm/models/chatassistantmessage.js

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d8ae826b4712
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatAssistantImages$inboundSchema, ChatAssistantImages$outboundSchema, } from "./chatassistantimages.js";
+import { ChatAudioOutput$inboundSchema, ChatAudioOutput$outboundSchema, } from "./chataudiooutput.js";
+import { ChatContentItems$inboundSchema, ChatContentItems$outboundSchema, } from "./chatcontentitems.js";
+import { ChatToolCall$inboundSchema, ChatToolCall$outboundSchema, } from "./chattoolcall.js";
+import { ReasoningDetailUnion$inboundSchema, ReasoningDetailUnion$outboundSchema, } from "./reasoningdetailunion.js";
+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()]);
+export function chatAssistantMessageContentToJSON(chatAssistantMessageContent) {
+    return JSON.stringify(ChatAssistantMessageContent$outboundSchema.parse(chatAssistantMessageContent));
+}
+export function chatAssistantMessageContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatAssistantMessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatAssistantMessageContent' from JSON`);
+}
+/** @internal */
+export const ChatAssistantMessage$inboundSchema = z.object({
+    role: ChatAssistantMessageRole$inboundSchema,
+    content: z.nullable(z.union([z.string(), z.array(ChatContentItems$inboundSchema), z.any()])).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(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_calls": "toolCalls",
+        "reasoning_details": "reasoningDetails",
+    });
+});
+/** @internal */
+export const ChatAssistantMessage$outboundSchema = z.object({
+    role: ChatAssistantMessageRole$outboundSchema,
+    content: z.nullable(z.union([z.string(), z.array(ChatContentItems$outboundSchema), z.any()])).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(),
+}).transform((v) => {
+    return remap$(v, {
+        toolCalls: "tool_calls",
+        reasoningDetails: "reasoning_details",
+    });
+});
+export function chatAssistantMessageToJSON(chatAssistantMessage) {
+    return JSON.stringify(ChatAssistantMessage$outboundSchema.parse(chatAssistantMessage));
+}
+export function chatAssistantMessageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatAssistantMessage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatAssistantMessage' from JSON`);
+}
+//# sourceMappingURL=chatassistantmessage.js.map

package/esm/models/chataudiooutput.d.ts

@@ -0,0 +1,38 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Audio output data or reference
+ */
+export type ChatAudioOutput = {
+    /**
+     * Audio output identifier
+     */
+    id?: string | undefined;
+    /**
+     * Audio expiration timestamp
+     */
+    expiresAt?: number | undefined;
+    /**
+     * Base64 encoded audio data
+     */
+    data?: string | undefined;
+    /**
+     * Audio transcript
+     */
+    transcript?: string | undefined;
+};
+/** @internal */
+export declare const ChatAudioOutput$inboundSchema: z.ZodType<ChatAudioOutput, unknown>;
+/** @internal */
+export type ChatAudioOutput$Outbound = {
+    id?: string | undefined;
+    expires_at?: number | undefined;
+    data?: string | undefined;
+    transcript?: string | undefined;
+};
+/** @internal */
+export declare const ChatAudioOutput$outboundSchema: z.ZodType<ChatAudioOutput$Outbound, ChatAudioOutput>;
+export declare function chatAudioOutputToJSON(chatAudioOutput: ChatAudioOutput): string;
+export declare function chatAudioOutputFromJSON(jsonString: string): SafeParseResult<ChatAudioOutput, SDKValidationError>;
+//# sourceMappingURL=chataudiooutput.d.ts.map

package/esm/models/chataudiooutput.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 692ef1eded11
+ */
+import * as z from "zod/v4";
+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(),
+    transcript: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "expires_at": "expiresAt",
+    });
+});
+/** @internal */
+export const ChatAudioOutput$outboundSchema = z.object({
+    id: z.string().optional(),
+    expiresAt: z.number().optional(),
+    data: z.string().optional(),
+    transcript: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        expiresAt: "expires_at",
+    });
+});
+export function chatAudioOutputToJSON(chatAudioOutput) {
+    return JSON.stringify(ChatAudioOutput$outboundSchema.parse(chatAudioOutput));
+}
+export function chatAudioOutputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatAudioOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatAudioOutput' from JSON`);
+}
+//# sourceMappingURL=chataudiooutput.js.map

package/esm/models/chatchoice.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatAssistantMessage } from "./chatassistantmessage.js";
+import { ChatTokenLogprobs } from "./chattokenlogprobs.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Chat completion choice
+ */
+export type ChatChoice = {
+    finishReason: any | null;
+    /**
+     * Choice index
+     */
+    index: number;
+    /**
+     * Assistant message for requests and responses
+     */
+    message: ChatAssistantMessage;
+    /**
+     * Log probabilities for the completion
+     */
+    logprobs?: ChatTokenLogprobs | null | undefined;
+};
+/** @internal */
+export declare const ChatChoice$inboundSchema: z.ZodType<ChatChoice, unknown>;
+export declare function chatChoiceFromJSON(jsonString: string): SafeParseResult<ChatChoice, SDKValidationError>;
+//# sourceMappingURL=chatchoice.d.ts.map

package/esm/models/chatchoice.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cb1eedd5b62e
+ */
+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 { ChatTokenLogprobs$inboundSchema, } from "./chattokenlogprobs.js";
+/** @internal */
+export const ChatChoice$inboundSchema = z
+    .object({
+    finish_reason: z.nullable(z.any()),
+    index: z.number(),
+    message: ChatAssistantMessage$inboundSchema,
+    logprobs: z.nullable(ChatTokenLogprobs$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "finish_reason": "finishReason",
+    });
+});
+export function chatChoiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatChoice' from JSON`);
+}
+//# sourceMappingURL=chatchoice.js.map

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/chatcontentfile.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 ChatContentFileType: {
+    readonly File: "file";
+};
+export type ChatContentFileType = ClosedEnum<typeof ChatContentFileType>;
+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 ChatContentFile = {
+    type: ChatContentFileType;
+    file: FileT;
+};
+/** @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 = {
+    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 ChatContentFile$inboundSchema: z.ZodType<ChatContentFile, unknown>;
+/** @internal */
+export type ChatContentFile$Outbound = {
+    type: string;
+    file: FileT$Outbound;
+};
+/** @internal */
+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/chatcontentfile.js

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @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 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(),
+    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 ChatContentFile$inboundSchema = z.object({
+    type: ChatContentFileType$inboundSchema,
+    file: z.lazy(() => FileT$inboundSchema),
+});
+/** @internal */
+export const ChatContentFile$outboundSchema = z.object({
+    type: ChatContentFileType$outboundSchema,
+    file: z.lazy(() => FileT$outboundSchema),
+});
+export function chatContentFileToJSON(chatContentFile) {
+    return JSON.stringify(ChatContentFile$outboundSchema.parse(chatContentFile));
+}
+export function chatContentFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentFile' from JSON`);
+}
+//# 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