@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/bulkunassignkeysresponse.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5906bcf3a524
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const BulkUnassignKeysResponse$inboundSchema = z.object({
+    unassigned_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "unassigned_count": "unassignedCount",
+    });
+});
+export function bulkUnassignKeysResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BulkUnassignKeysResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkUnassignKeysResponse' from JSON`);
+}
+//# sourceMappingURL=bulkunassignkeysresponse.js.map

package/esm/models/bulkunassignmembersrequest.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+export type BulkUnassignMembersRequest = {
+    /**
+     * Array of member user IDs to unassign from the guardrail
+     */
+    memberUserIds: Array<string>;
+};
+/** @internal */
+export type BulkUnassignMembersRequest$Outbound = {
+    member_user_ids: Array<string>;
+};
+/** @internal */
+export declare const BulkUnassignMembersRequest$outboundSchema: z.ZodType<BulkUnassignMembersRequest$Outbound, BulkUnassignMembersRequest>;
+export declare function bulkUnassignMembersRequestToJSON(bulkUnassignMembersRequest: BulkUnassignMembersRequest): string;
+//# sourceMappingURL=bulkunassignmembersrequest.d.ts.map

package/esm/models/bulkunassignmembersrequest.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3443354340f5
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const BulkUnassignMembersRequest$outboundSchema = z.object({
+    memberUserIds: z.array(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        memberUserIds: "member_user_ids",
+    });
+});
+export function bulkUnassignMembersRequestToJSON(bulkUnassignMembersRequest) {
+    return JSON.stringify(BulkUnassignMembersRequest$outboundSchema.parse(bulkUnassignMembersRequest));
+}
+//# sourceMappingURL=bulkunassignmembersrequest.js.map

package/esm/models/bulkunassignmembersresponse.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type BulkUnassignMembersResponse = {
+    /**
+     * Number of members successfully unassigned
+     */
+    unassignedCount: number;
+};
+/** @internal */
+export declare const BulkUnassignMembersResponse$inboundSchema: z.ZodType<BulkUnassignMembersResponse, unknown>;
+export declare function bulkUnassignMembersResponseFromJSON(jsonString: string): SafeParseResult<BulkUnassignMembersResponse, SDKValidationError>;
+//# sourceMappingURL=bulkunassignmembersresponse.d.ts.map

package/esm/models/bulkunassignmembersresponse.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4d3857aa5f6c
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const BulkUnassignMembersResponse$inboundSchema = z.object({
+    unassigned_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "unassigned_count": "unassignedCount",
+    });
+});
+export function bulkUnassignMembersResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BulkUnassignMembersResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkUnassignMembersResponse' from JSON`);
+}
+//# sourceMappingURL=bulkunassignmembersresponse.js.map

package/esm/models/chatassistantimages.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ChatAssistantImagesImageUrl = {
+    /**
+     * URL or base64-encoded data of the generated image
+     */
+    url: string;
+};
+export type ChatAssistantImages = {
+    imageUrl: ChatAssistantImagesImageUrl;
+};
+/** @internal */
+export declare const ChatAssistantImagesImageUrl$inboundSchema: z.ZodType<ChatAssistantImagesImageUrl, unknown>;
+/** @internal */
+export type ChatAssistantImagesImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const ChatAssistantImagesImageUrl$outboundSchema: z.ZodType<ChatAssistantImagesImageUrl$Outbound, ChatAssistantImagesImageUrl>;
+export declare function chatAssistantImagesImageUrlToJSON(chatAssistantImagesImageUrl: ChatAssistantImagesImageUrl): string;
+export declare function chatAssistantImagesImageUrlFromJSON(jsonString: string): SafeParseResult<ChatAssistantImagesImageUrl, SDKValidationError>;
+/** @internal */
+export declare const ChatAssistantImages$inboundSchema: z.ZodType<ChatAssistantImages, unknown>;
+/** @internal */
+export type ChatAssistantImages$Outbound = {
+    image_url: ChatAssistantImagesImageUrl$Outbound;
+};
+/** @internal */
+export declare const ChatAssistantImages$outboundSchema: z.ZodType<ChatAssistantImages$Outbound, ChatAssistantImages>;
+export declare function chatAssistantImagesToJSON(chatAssistantImages: ChatAssistantImages): string;
+export declare function chatAssistantImagesFromJSON(jsonString: string): SafeParseResult<ChatAssistantImages, SDKValidationError>;
+//# sourceMappingURL=chatassistantimages.d.ts.map

package/esm/models/chatassistantimages.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 31fb8a4309f9
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ChatAssistantImagesImageUrl$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const ChatAssistantImagesImageUrl$outboundSchema = z.object({
+    url: z.string(),
+});
+export function chatAssistantImagesImageUrlToJSON(chatAssistantImagesImageUrl) {
+    return JSON.stringify(ChatAssistantImagesImageUrl$outboundSchema.parse(chatAssistantImagesImageUrl));
+}
+export function chatAssistantImagesImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatAssistantImagesImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatAssistantImagesImageUrl' from JSON`);
+}
+/** @internal */
+export const ChatAssistantImages$inboundSchema = z.object({
+    image_url: z.lazy(() => ChatAssistantImagesImageUrl$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const ChatAssistantImages$outboundSchema = z.object({
+    imageUrl: z.lazy(() => ChatAssistantImagesImageUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function chatAssistantImagesToJSON(chatAssistantImages) {
+    return JSON.stringify(ChatAssistantImages$outboundSchema.parse(chatAssistantImages));
+}
+export function chatAssistantImagesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatAssistantImages$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatAssistantImages' from JSON`);
+}
+//# sourceMappingURL=chatassistantimages.js.map

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";
+/**
+ * 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 = {
+    /**
+     * Audio output data or reference
+     */
+    audio?: ChatAudioOutput | undefined;
+    /**
+     * Assistant message content
+     */
+    content?: string | Array<ChatContentItems> | any | null | undefined;
+    /**
+     * Generated images from image generation models
+     */
+    images?: Array<ChatAssistantImages> | undefined;
+    /**
+     * Optional name for the assistant
+     */
+    name?: string | undefined;
+    /**
+     * Reasoning output
+     */
+    reasoning?: string | null | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
+    /**
+     * Refusal message if content was refused
+     */
+    refusal?: string | null | undefined;
+    role: ChatAssistantMessageRole;
+    /**
+     * Tool calls made by the assistant
+     */
+    toolCalls?: Array<ChatToolCall> | undefined;
+};
+/** @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 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 = {
+    audio?: ChatAudioOutput$Outbound | undefined;
+    content?: string | Array<ChatContentItems$Outbound> | any | null | undefined;
+    images?: Array<ChatAssistantImages$Outbound> | undefined;
+    name?: string | undefined;
+    reasoning?: string | null | undefined;
+    reasoning_details?: Array<ReasoningDetailUnion$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>;
+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 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 ChatAssistantMessageRole$inboundSchema = z.enum(ChatAssistantMessageRole);
+/** @internal */
+export const ChatAssistantMessageRole$outboundSchema = ChatAssistantMessageRole$inboundSchema;
+/** @internal */
+export const ChatAssistantMessage$inboundSchema = z.object({
+    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(),
+    reasoning: z.nullable(z.string()).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
+    refusal: z.nullable(z.string()).optional(),
+    role: ChatAssistantMessageRole$inboundSchema,
+    tool_calls: z.array(ChatToolCall$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "reasoning_details": "reasoningDetails",
+        "tool_calls": "toolCalls",
+    });
+});
+/** @internal */
+export const ChatAssistantMessage$outboundSchema = z.object({
+    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(),
+    reasoning: z.nullable(z.string()).optional(),
+    reasoningDetails: z.array(ReasoningDetailUnion$outboundSchema).optional(),
+    refusal: z.nullable(z.string()).optional(),
+    role: ChatAssistantMessageRole$outboundSchema,
+    toolCalls: z.array(ChatToolCall$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        reasoningDetails: "reasoning_details",
+        toolCalls: "tool_calls",
+    });
+});
+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/{chatcompletionaudiooutput.d.ts → chataudiooutput.d.ts}

@@ -4,35 +4,35 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Audio output data or reference
  */
-export type ChatCompletionAudioOutput = {
+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
      */
     transcript?: string | undefined;
 };
 /** @internal */
-export declare const ChatCompletionAudioOutput$inboundSchema: z.ZodType<ChatCompletionAudioOutput, unknown>;
+export declare const ChatAudioOutput$inboundSchema: z.ZodType<ChatAudioOutput, unknown>;
 /** @internal */
-export type ChatCompletionAudioOutput$Outbound = {
-    id?: string | undefined;
-    expires_at?: number | undefined;
+export type ChatAudioOutput$Outbound = {
     data?: string | undefined;
+    expires_at?: number | undefined;
+    id?: string | undefined;
     transcript?: string | undefined;
 };
 /** @internal */
-export declare const ChatCompletionAudioOutput$outboundSchema: z.ZodType<ChatCompletionAudioOutput$Outbound, ChatCompletionAudioOutput>;
-export declare function chatCompletionAudioOutputToJSON(chatCompletionAudioOutput: ChatCompletionAudioOutput): string;
-export declare function chatCompletionAudioOutputFromJSON(jsonString: string): SafeParseResult<ChatCompletionAudioOutput, SDKValidationError>;
-//# sourceMappingURL=chatcompletionaudiooutput.d.ts.map
+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({
+    data: z.string().optional(),
+    expires_at: z.int().optional(),
+    id: z.string().optional(),
+    transcript: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "expires_at": "expiresAt",
+    });
+});
+/** @internal */
+export const ChatAudioOutput$outboundSchema = z.object({
+    data: z.string().optional(),
+    expiresAt: z.int().optional(),
+    id: 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,28 @@
+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: ChatFinishReasonEnum | null;
+    /**
+     * Choice index
+     */
+    index: number;
+    /**
+     * 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>;
+export declare function chatChoiceFromJSON(jsonString: string): SafeParseResult<ChatChoice, SDKValidationError>;
+//# sourceMappingURL=chatchoice.d.ts.map

package/esm/models/chatchoice.js

@@ -0,0 +1,26 @@
+/*
+ * 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 { ChatFinishReasonEnum$inboundSchema, } from "./chatfinishreasonenum.js";
+import { ChatTokenLogprobs$inboundSchema, } from "./chattokenlogprobs.js";
+/** @internal */
+export const ChatChoice$inboundSchema = z
+    .object({
+    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",
+    });
+});
+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,43 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+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 = {
+    inputAudio: ChatContentAudioInputAudio;
+    type: "input_audio";
+};
+/** @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 = {
+    input_audio: ChatContentAudioInputAudio$Outbound;
+    type: "input_audio";
+};
+/** @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,48 @@
+/*
+ * 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";
+/** @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({
+    input_audio: z.lazy(() => ChatContentAudioInputAudio$inboundSchema),
+    type: z.literal("input_audio"),
+}).transform((v) => {
+    return remap$(v, {
+        "input_audio": "inputAudio",
+    });
+});
+/** @internal */
+export const ChatContentAudio$outboundSchema = z.object({
+    inputAudio: z.lazy(() => ChatContentAudioInputAudio$outboundSchema),
+    type: z.literal("input_audio"),
+}).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,32 @@
+import * as z from "zod/v4";
+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>;
+/**
+ * Cache control for the content part
+ */
+export type ChatContentCacheControl = {
+    ttl?: AnthropicCacheControlTtl | undefined;
+    type: ChatContentCacheControlType;
+};
+/** @internal */
+export declare const ChatContentCacheControlType$inboundSchema: z.ZodEnum<typeof ChatContentCacheControlType>;
+/** @internal */
+export declare const ChatContentCacheControlType$outboundSchema: z.ZodEnum<typeof ChatContentCacheControlType>;
+/** @internal */
+export declare const ChatContentCacheControl$inboundSchema: z.ZodType<ChatContentCacheControl, unknown>;
+/** @internal */
+export type ChatContentCacheControl$Outbound = {
+    ttl?: string | undefined;
+    type: string;
+};
+/** @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,31 @@
+/*
+ * 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 { AnthropicCacheControlTtl$inboundSchema, AnthropicCacheControlTtl$outboundSchema, } from "./anthropiccachecontrolttl.js";
+export const ChatContentCacheControlType = {
+    Ephemeral: "ephemeral",
+};
+/** @internal */
+export const ChatContentCacheControlType$inboundSchema = z.enum(ChatContentCacheControlType);
+/** @internal */
+export const ChatContentCacheControlType$outboundSchema = ChatContentCacheControlType$inboundSchema;
+/** @internal */
+export const ChatContentCacheControl$inboundSchema = z.object({
+    ttl: AnthropicCacheControlTtl$inboundSchema.optional(),
+    type: ChatContentCacheControlType$inboundSchema,
+});
+/** @internal */
+export const ChatContentCacheControl$outboundSchema = z.object({
+    ttl: AnthropicCacheControlTtl$outboundSchema.optional(),
+    type: ChatContentCacheControlType$outboundSchema,
+});
+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