@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/chatgenerationparams.js

@@ -1,413 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: f98a2a558f3f
- */
-import * as z from "zod/v4";
-import { remap as remap$ } from "../lib/primitives.js";
-import * as openEnums from "../types/enums.js";
-import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
-import { ContextCompressionEngine$outboundSchema, } from "./contextcompressionengine.js";
-import { DataCollection$outboundSchema, } from "./datacollection.js";
-import { DebugOptions$outboundSchema, } from "./debugoptions.js";
-import { Message$outboundSchema, } from "./message.js";
-import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.js";
-import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
-import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
-import { ProviderName$outboundSchema } from "./providername.js";
-import { Quantization$outboundSchema } from "./quantization.js";
-import { ResponseFormatJSONObject$outboundSchema, } from "./responseformatjsonobject.js";
-import { ResponseFormatJSONSchema$outboundSchema, } from "./responseformatjsonschema.js";
-import { ResponseFormatText$outboundSchema, } from "./responseformattext.js";
-import { ResponseFormatTextGrammar$outboundSchema, } from "./responseformattextgrammar.js";
-import { ResponseFormatTextPython$outboundSchema, } from "./responseformattextpython.js";
-import { ToolChoiceOption$outboundSchema, } from "./toolchoiceoption.js";
-import { ToolDefinitionJson$outboundSchema, } from "./tooldefinitionjson.js";
-import { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
-export const ChatGenerationParamsSortEnum = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-export const ChatGenerationParamsProviderSortConfigEnum = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * The provider sorting strategy (price, throughput, latency)
- */
-export const ChatGenerationParamsBy = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
- */
-export const ChatGenerationParamsPartition = {
-    Model: "model",
-    None: "none",
-};
-/**
- * The provider sorting strategy (price, throughput, latency)
- */
-export const ChatGenerationParamsProviderSort = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
-    Exacto: "exacto",
-};
-/**
- * Constrains effort on reasoning for reasoning models
- */
-export const Effort = {
-    Xhigh: "xhigh",
-    High: "high",
-    Medium: "medium",
-    Low: "low",
-    Minimal: "minimal",
-    None: "none",
-};
-export const Modality = {
-    Text: "text",
-    Image: "image",
-    Audio: "audio",
-};
-export const ChatGenerationParamsType = {
-    Ephemeral: "ephemeral",
-};
-export const ChatGenerationParamsTtl = {
-    Fivem: "5m",
-    Oneh: "1h",
-};
-/** @internal */
-export const ChatGenerationParamsOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function chatGenerationParamsOrderToJSON(chatGenerationParamsOrder) {
-    return JSON.stringify(ChatGenerationParamsOrder$outboundSchema.parse(chatGenerationParamsOrder));
-}
-/** @internal */
-export const ChatGenerationParamsOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function chatGenerationParamsOnlyToJSON(chatGenerationParamsOnly) {
-    return JSON.stringify(ChatGenerationParamsOnly$outboundSchema.parse(chatGenerationParamsOnly));
-}
-/** @internal */
-export const ChatGenerationParamsIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
-export function chatGenerationParamsIgnoreToJSON(chatGenerationParamsIgnore) {
-    return JSON.stringify(ChatGenerationParamsIgnore$outboundSchema.parse(chatGenerationParamsIgnore));
-}
-/** @internal */
-export const ChatGenerationParamsSortEnum$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsSortEnum);
-/** @internal */
-export const ChatGenerationParamsProviderSortConfigEnum$outboundSchema = z.enum(ChatGenerationParamsProviderSortConfigEnum);
-/** @internal */
-export const ChatGenerationParamsBy$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsBy);
-/** @internal */
-export const ChatGenerationParamsPartition$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsPartition);
-/** @internal */
-export const ChatGenerationParamsProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ChatGenerationParamsBy$outboundSchema).optional(),
-    partition: z.nullable(ChatGenerationParamsPartition$outboundSchema)
-        .optional(),
-});
-export function chatGenerationParamsProviderSortConfigToJSON(chatGenerationParamsProviderSortConfig) {
-    return JSON.stringify(ChatGenerationParamsProviderSortConfig$outboundSchema.parse(chatGenerationParamsProviderSortConfig));
-}
-/** @internal */
-export const ChatGenerationParamsProviderSortConfigUnion$outboundSchema = z.union([
-    z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
-    ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
-]);
-export function chatGenerationParamsProviderSortConfigUnionToJSON(chatGenerationParamsProviderSortConfigUnion) {
-    return JSON.stringify(ChatGenerationParamsProviderSortConfigUnion$outboundSchema.parse(chatGenerationParamsProviderSortConfigUnion));
-}
-/** @internal */
-export const ChatGenerationParamsProviderSort$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsProviderSort);
-/** @internal */
-export const ChatGenerationParamsSortUnion$outboundSchema = z.union([
-    ChatGenerationParamsProviderSort$outboundSchema,
-    z.union([
-        z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
-        ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
-    ]),
-    ChatGenerationParamsSortEnum$outboundSchema,
-]);
-export function chatGenerationParamsSortUnionToJSON(chatGenerationParamsSortUnion) {
-    return JSON.stringify(ChatGenerationParamsSortUnion$outboundSchema.parse(chatGenerationParamsSortUnion));
-}
-/** @internal */
-export const ChatGenerationParamsMaxPrice$outboundSchema = z.object({
-    prompt: z.string().optional(),
-    completion: z.string().optional(),
-    image: z.string().optional(),
-    audio: z.string().optional(),
-    request: z.string().optional(),
-});
-export function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice) {
-    return JSON.stringify(ChatGenerationParamsMaxPrice$outboundSchema.parse(chatGenerationParamsMaxPrice));
-}
-/** @internal */
-export const ChatGenerationParamsProvider$outboundSchema = z.object({
-    allowFallbacks: z.nullable(z.boolean()).optional(),
-    requireParameters: z.nullable(z.boolean()).optional(),
-    dataCollection: z.nullable(DataCollection$outboundSchema).optional(),
-    zdr: z.nullable(z.boolean()).optional(),
-    enforceDistillableText: z.nullable(z.boolean()).optional(),
-    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
-        .optional(),
-    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
-        .optional(),
-    ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
-    quantizations: z.nullable(z.array(Quantization$outboundSchema)).optional(),
-    sort: z.nullable(z.union([
-        ChatGenerationParamsProviderSort$outboundSchema,
-        z.union([
-            z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
-            ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
-        ]),
-        ChatGenerationParamsSortEnum$outboundSchema,
-    ])).optional(),
-    maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
-        .optional(),
-    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
-        .optional(),
-    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
-        .optional(),
-}).transform((v) => {
-    return remap$(v, {
-        allowFallbacks: "allow_fallbacks",
-        requireParameters: "require_parameters",
-        dataCollection: "data_collection",
-        enforceDistillableText: "enforce_distillable_text",
-        maxPrice: "max_price",
-        preferredMinThroughput: "preferred_min_throughput",
-        preferredMaxLatency: "preferred_max_latency",
-    });
-});
-export function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider) {
-    return JSON.stringify(ChatGenerationParamsProvider$outboundSchema.parse(chatGenerationParamsProvider));
-}
-/** @internal */
-export const ChatGenerationParamsPluginContextCompression$outboundSchema = z.object({
-    id: z.literal("context-compression"),
-    enabled: z.boolean().optional(),
-    engine: ContextCompressionEngine$outboundSchema.optional(),
-});
-export function chatGenerationParamsPluginContextCompressionToJSON(chatGenerationParamsPluginContextCompression) {
-    return JSON.stringify(ChatGenerationParamsPluginContextCompression$outboundSchema.parse(chatGenerationParamsPluginContextCompression));
-}
-/** @internal */
-export const ChatGenerationParamsPluginResponseHealing$outboundSchema = z.object({
-    id: z.literal("response-healing"),
-    enabled: z.boolean().optional(),
-});
-export function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing) {
-    return JSON.stringify(ChatGenerationParamsPluginResponseHealing$outboundSchema.parse(chatGenerationParamsPluginResponseHealing));
-}
-/** @internal */
-export const ChatGenerationParamsPluginFileParser$outboundSchema = z.object({
-    id: z.literal("file-parser"),
-    enabled: z.boolean().optional(),
-    pdf: PDFParserOptions$outboundSchema.optional(),
-});
-export function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser) {
-    return JSON.stringify(ChatGenerationParamsPluginFileParser$outboundSchema.parse(chatGenerationParamsPluginFileParser));
-}
-/** @internal */
-export const ChatGenerationParamsPluginWeb$outboundSchema = z.object({
-    id: z.literal("web"),
-    enabled: z.boolean().optional(),
-    maxResults: z.number().optional(),
-    searchPrompt: z.string().optional(),
-    engine: WebSearchEngine$outboundSchema.optional(),
-    includeDomains: z.array(z.string()).optional(),
-    excludeDomains: z.array(z.string()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        maxResults: "max_results",
-        searchPrompt: "search_prompt",
-        includeDomains: "include_domains",
-        excludeDomains: "exclude_domains",
-    });
-});
-export function chatGenerationParamsPluginWebToJSON(chatGenerationParamsPluginWeb) {
-    return JSON.stringify(ChatGenerationParamsPluginWeb$outboundSchema.parse(chatGenerationParamsPluginWeb));
-}
-/** @internal */
-export const ChatGenerationParamsPluginModeration$outboundSchema = z.object({
-    id: z.literal("moderation"),
-});
-export function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration) {
-    return JSON.stringify(ChatGenerationParamsPluginModeration$outboundSchema.parse(chatGenerationParamsPluginModeration));
-}
-/** @internal */
-export const ChatGenerationParamsPluginAutoRouter$outboundSchema = z.object({
-    id: z.literal("auto-router"),
-    enabled: z.boolean().optional(),
-    allowedModels: z.array(z.string()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        allowedModels: "allowed_models",
-    });
-});
-export function chatGenerationParamsPluginAutoRouterToJSON(chatGenerationParamsPluginAutoRouter) {
-    return JSON.stringify(ChatGenerationParamsPluginAutoRouter$outboundSchema.parse(chatGenerationParamsPluginAutoRouter));
-}
-/** @internal */
-export const ChatGenerationParamsPluginUnion$outboundSchema = z.union([
-    z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
-    z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
-    z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
-    z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
-    z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
-    z.lazy(() => ChatGenerationParamsPluginContextCompression$outboundSchema),
-]);
-export function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion) {
-    return JSON.stringify(ChatGenerationParamsPluginUnion$outboundSchema.parse(chatGenerationParamsPluginUnion));
-}
-/** @internal */
-export const ChatGenerationParamsTrace$outboundSchema = z.object({
-    traceId: z.string().optional(),
-    traceName: z.string().optional(),
-    spanName: z.string().optional(),
-    generationName: z.string().optional(),
-    parentSpanId: z.string().optional(),
-    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
-}).transform((v) => {
-    return {
-        ...v.additionalProperties,
-        ...remap$(v, {
-            traceId: "trace_id",
-            traceName: "trace_name",
-            spanName: "span_name",
-            generationName: "generation_name",
-            parentSpanId: "parent_span_id",
-            additionalProperties: null,
-        }),
-    };
-});
-export function chatGenerationParamsTraceToJSON(chatGenerationParamsTrace) {
-    return JSON.stringify(ChatGenerationParamsTrace$outboundSchema.parse(chatGenerationParamsTrace));
-}
-/** @internal */
-export const Effort$outboundSchema = openEnums
-    .outboundSchema(Effort);
-/** @internal */
-export const Reasoning$outboundSchema = z.object({
-    effort: z.nullable(Effort$outboundSchema).optional(),
-    summary: z.nullable(z.any()).optional(),
-});
-export function reasoningToJSON(reasoning) {
-    return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
-}
-/** @internal */
-export const ResponseFormat$outboundSchema = z.union([
-    ResponseFormatText$outboundSchema,
-    ResponseFormatJSONObject$outboundSchema,
-    ResponseFormatJSONSchema$outboundSchema,
-    ResponseFormatTextGrammar$outboundSchema,
-    ResponseFormatTextPython$outboundSchema,
-]);
-export function responseFormatToJSON(responseFormat) {
-    return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
-}
-/** @internal */
-export const Stop$outboundSchema = z.union([
-    z.string(),
-    z.array(z.string()),
-    z.any(),
-]);
-export function stopToJSON(stop) {
-    return JSON.stringify(Stop$outboundSchema.parse(stop));
-}
-/** @internal */
-export const ChatGenerationParamsImageConfig$outboundSchema = z.union([z.string(), z.number(), z.array(z.nullable(z.any()))]);
-export function chatGenerationParamsImageConfigToJSON(chatGenerationParamsImageConfig) {
-    return JSON.stringify(ChatGenerationParamsImageConfig$outboundSchema.parse(chatGenerationParamsImageConfig));
-}
-/** @internal */
-export const Modality$outboundSchema = openEnums
-    .outboundSchema(Modality);
-/** @internal */
-export const ChatGenerationParamsType$outboundSchema = z.enum(ChatGenerationParamsType);
-/** @internal */
-export const ChatGenerationParamsTtl$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsTtl);
-/** @internal */
-export const CacheControl$outboundSchema = z.object({
-    type: ChatGenerationParamsType$outboundSchema,
-    ttl: ChatGenerationParamsTtl$outboundSchema.optional(),
-});
-export function cacheControlToJSON(cacheControl) {
-    return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
-}
-/** @internal */
-export const ChatGenerationParams$outboundSchema = z.object({
-    provider: z.nullable(z.lazy(() => ChatGenerationParamsProvider$outboundSchema)).optional(),
-    plugins: z.array(z.union([
-        z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
-        z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
-        z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
-        z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
-        z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
-        z.lazy(() => ChatGenerationParamsPluginContextCompression$outboundSchema),
-    ])).optional(),
-    user: z.string().optional(),
-    sessionId: z.string().optional(),
-    trace: z.lazy(() => ChatGenerationParamsTrace$outboundSchema).optional(),
-    messages: z.array(Message$outboundSchema),
-    model: z.string().optional(),
-    models: z.array(z.string()).optional(),
-    frequencyPenalty: z.nullable(z.number()).optional(),
-    logitBias: z.nullable(z.record(z.string(), z.number())).optional(),
-    logprobs: z.nullable(z.boolean()).optional(),
-    topLogprobs: z.nullable(z.number()).optional(),
-    maxCompletionTokens: z.nullable(z.number()).optional(),
-    maxTokens: z.nullable(z.number()).optional(),
-    metadata: z.record(z.string(), z.string()).optional(),
-    presencePenalty: z.nullable(z.number()).optional(),
-    reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
-    responseFormat: z.union([
-        ResponseFormatText$outboundSchema,
-        ResponseFormatJSONObject$outboundSchema,
-        ResponseFormatJSONSchema$outboundSchema,
-        ResponseFormatTextGrammar$outboundSchema,
-        ResponseFormatTextPython$outboundSchema,
-    ]).optional(),
-    seed: z.nullable(z.int()).optional(),
-    stop: z.nullable(z.union([z.string(), z.array(z.string()), z.any()]))
-        .optional(),
-    stream: z.boolean().default(false),
-    streamOptions: z.nullable(ChatStreamOptions$outboundSchema).optional(),
-    temperature: z.nullable(z.number().default(1)),
-    parallelToolCalls: z.nullable(z.boolean()).optional(),
-    toolChoice: ToolChoiceOption$outboundSchema.optional(),
-    tools: z.array(ToolDefinitionJson$outboundSchema).optional(),
-    topP: z.nullable(z.number().default(1)),
-    debug: DebugOptions$outboundSchema.optional(),
-    imageConfig: z.record(z.string(), z.union([z.string(), z.number(), z.array(z.nullable(z.any()))])).optional(),
-    modalities: z.array(Modality$outboundSchema).optional(),
-    cacheControl: z.lazy(() => CacheControl$outboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        sessionId: "session_id",
-        frequencyPenalty: "frequency_penalty",
-        logitBias: "logit_bias",
-        topLogprobs: "top_logprobs",
-        maxCompletionTokens: "max_completion_tokens",
-        maxTokens: "max_tokens",
-        presencePenalty: "presence_penalty",
-        responseFormat: "response_format",
-        streamOptions: "stream_options",
-        parallelToolCalls: "parallel_tool_calls",
-        toolChoice: "tool_choice",
-        topP: "top_p",
-        imageConfig: "image_config",
-        cacheControl: "cache_control",
-    });
-});
-export function chatGenerationParamsToJSON(chatGenerationParams) {
-    return JSON.stringify(ChatGenerationParams$outboundSchema.parse(chatGenerationParams));
-}
-//# sourceMappingURL=chatgenerationparams.js.map

package/esm/models/chatmessagecontentitem.d.ts

@@ -1,31 +0,0 @@
-import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatMessageContentItemAudio, ChatMessageContentItemAudio$Outbound } from "./chatmessagecontentitemaudio.js";
-import { ChatMessageContentItemFile, ChatMessageContentItemFile$Outbound } from "./chatmessagecontentitemfile.js";
-import { ChatMessageContentItemImage, ChatMessageContentItemImage$Outbound } from "./chatmessagecontentitemimage.js";
-import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
-import { ChatMessageContentItemVideo, ChatMessageContentItemVideo$Outbound } from "./chatmessagecontentitemvideo.js";
-import { ChatMessageContentItemVideoLegacy, ChatMessageContentItemVideoLegacy$Outbound } from "./chatmessagecontentitemvideolegacy.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatMessageContentItem1 = ChatMessageContentItemVideoLegacy | ChatMessageContentItemVideo;
-/**
- * Content part for chat completion messages
- */
-export type ChatMessageContentItem = ChatMessageContentItemText | ChatMessageContentItemImage | ChatMessageContentItemAudio | ChatMessageContentItemFile | ChatMessageContentItemVideoLegacy | ChatMessageContentItemVideo;
-/** @internal */
-export declare const ChatMessageContentItem1$inboundSchema: z.ZodType<ChatMessageContentItem1, unknown>;
-/** @internal */
-export type ChatMessageContentItem1$Outbound = ChatMessageContentItemVideoLegacy$Outbound | ChatMessageContentItemVideo$Outbound;
-/** @internal */
-export declare const ChatMessageContentItem1$outboundSchema: z.ZodType<ChatMessageContentItem1$Outbound, ChatMessageContentItem1>;
-export declare function chatMessageContentItem1ToJSON(chatMessageContentItem1: ChatMessageContentItem1): string;
-export declare function chatMessageContentItem1FromJSON(jsonString: string): SafeParseResult<ChatMessageContentItem1, SDKValidationError>;
-/** @internal */
-export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
-/** @internal */
-export type ChatMessageContentItem$Outbound = ChatMessageContentItemText$Outbound | ChatMessageContentItemImage$Outbound | ChatMessageContentItemAudio$Outbound | ChatMessageContentItemFile$Outbound | ChatMessageContentItemVideoLegacy$Outbound | ChatMessageContentItemVideo$Outbound;
-/** @internal */
-export declare const ChatMessageContentItem$outboundSchema: z.ZodType<ChatMessageContentItem$Outbound, ChatMessageContentItem>;
-export declare function chatMessageContentItemToJSON(chatMessageContentItem: ChatMessageContentItem): string;
-export declare function chatMessageContentItemFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItem, SDKValidationError>;
-//# sourceMappingURL=chatmessagecontentitem.d.ts.map

package/esm/models/chatmessagecontentitem.js

@@ -1,57 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: bb7f6b29b93f
- */
-import * as z from "zod/v4";
-import { safeParse } from "../lib/schemas.js";
-import { ChatMessageContentItemAudio$inboundSchema, ChatMessageContentItemAudio$outboundSchema, } from "./chatmessagecontentitemaudio.js";
-import { ChatMessageContentItemFile$inboundSchema, ChatMessageContentItemFile$outboundSchema, } from "./chatmessagecontentitemfile.js";
-import { ChatMessageContentItemImage$inboundSchema, ChatMessageContentItemImage$outboundSchema, } from "./chatmessagecontentitemimage.js";
-import { ChatMessageContentItemText$inboundSchema, ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
-import { ChatMessageContentItemVideo$inboundSchema, ChatMessageContentItemVideo$outboundSchema, } from "./chatmessagecontentitemvideo.js";
-import { ChatMessageContentItemVideoLegacy$inboundSchema, ChatMessageContentItemVideoLegacy$outboundSchema, } from "./chatmessagecontentitemvideolegacy.js";
-/** @internal */
-export const ChatMessageContentItem1$inboundSchema = z.union([
-    ChatMessageContentItemVideoLegacy$inboundSchema,
-    ChatMessageContentItemVideo$inboundSchema,
-]);
-/** @internal */
-export const ChatMessageContentItem1$outboundSchema = z.union([
-    ChatMessageContentItemVideoLegacy$outboundSchema,
-    ChatMessageContentItemVideo$outboundSchema,
-]);
-export function chatMessageContentItem1ToJSON(chatMessageContentItem1) {
-    return JSON.stringify(ChatMessageContentItem1$outboundSchema.parse(chatMessageContentItem1));
-}
-export function chatMessageContentItem1FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItem1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItem1' from JSON`);
-}
-/** @internal */
-export const ChatMessageContentItem$inboundSchema = z.union([
-    ChatMessageContentItemText$inboundSchema,
-    ChatMessageContentItemImage$inboundSchema,
-    ChatMessageContentItemAudio$inboundSchema,
-    ChatMessageContentItemFile$inboundSchema,
-    z.union([
-        ChatMessageContentItemVideoLegacy$inboundSchema,
-        ChatMessageContentItemVideo$inboundSchema,
-    ]),
-]);
-/** @internal */
-export const ChatMessageContentItem$outboundSchema = z.union([
-    ChatMessageContentItemText$outboundSchema,
-    ChatMessageContentItemImage$outboundSchema,
-    ChatMessageContentItemAudio$outboundSchema,
-    ChatMessageContentItemFile$outboundSchema,
-    z.union([
-        ChatMessageContentItemVideoLegacy$outboundSchema,
-        ChatMessageContentItemVideo$outboundSchema,
-    ]),
-]);
-export function chatMessageContentItemToJSON(chatMessageContentItem) {
-    return JSON.stringify(ChatMessageContentItem$outboundSchema.parse(chatMessageContentItem));
-}
-export function chatMessageContentItemFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItem' from JSON`);
-}
-//# sourceMappingURL=chatmessagecontentitem.js.map

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -1,52 +0,0 @@
-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: 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 = {
-    data: string;
-    format: string;
-};
-/** @internal */
-export declare const ChatMessageContentItemAudioInputAudio$outboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio$Outbound, ChatMessageContentItemAudioInputAudio>;
-export declare function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio: ChatMessageContentItemAudioInputAudio): string;
-export declare function chatMessageContentItemAudioInputAudioFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemAudioInputAudio, SDKValidationError>;
-/** @internal */
-export declare const ChatMessageContentItemAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudio, unknown>;
-/** @internal */
-export type ChatMessageContentItemAudio$Outbound = {
-    type: string;
-    input_audio: ChatMessageContentItemAudioInputAudio$Outbound;
-};
-/** @internal */
-export declare const ChatMessageContentItemAudio$outboundSchema: z.ZodType<ChatMessageContentItemAudio$Outbound, ChatMessageContentItemAudio>;
-export declare function chatMessageContentItemAudioToJSON(chatMessageContentItemAudio: ChatMessageContentItemAudio): string;
-export declare function chatMessageContentItemAudioFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemAudio, SDKValidationError>;
-//# sourceMappingURL=chatmessagecontentitemaudio.d.ts.map

package/esm/models/chatmessagecontentitemaudio.js

@@ -1,55 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 49b1cafcb338
- */
-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(),
-    format: z.string(),
-});
-/** @internal */
-export const ChatMessageContentItemAudioInputAudio$outboundSchema = z.object({
-    data: z.string(),
-    format: z.string(),
-});
-export function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio) {
-    return JSON.stringify(ChatMessageContentItemAudioInputAudio$outboundSchema.parse(chatMessageContentItemAudioInputAudio));
-}
-export function chatMessageContentItemAudioInputAudioFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemAudioInputAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemAudioInputAudio' from JSON`);
-}
-/** @internal */
-export const ChatMessageContentItemAudio$inboundSchema = z.object({
-    type: ChatMessageContentItemAudioType$inboundSchema,
-    input_audio: z.lazy(() => ChatMessageContentItemAudioInputAudio$inboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        "input_audio": "inputAudio",
-    });
-});
-/** @internal */
-export const ChatMessageContentItemAudio$outboundSchema = z.object({
-    type: ChatMessageContentItemAudioType$outboundSchema,
-    inputAudio: z.lazy(() => ChatMessageContentItemAudioInputAudio$outboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        inputAudio: "input_audio",
-    });
-});
-export function chatMessageContentItemAudioToJSON(chatMessageContentItemAudio) {
-    return JSON.stringify(ChatMessageContentItemAudio$outboundSchema.parse(chatMessageContentItemAudio));
-}
-export function chatMessageContentItemAudioFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemAudio$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemAudio' from JSON`);
-}
-//# sourceMappingURL=chatmessagecontentitemaudio.js.map

package/esm/models/chatmessagecontentitemcachecontrol.d.ts

@@ -1,40 +0,0 @@
-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 ChatMessageContentItemCacheControlType: {
-    readonly Ephemeral: "ephemeral";
-};
-export type ChatMessageContentItemCacheControlType = ClosedEnum<typeof ChatMessageContentItemCacheControlType>;
-export declare const ChatMessageContentItemCacheControlTtl: {
-    readonly Fivem: "5m";
-    readonly Oneh: "1h";
-};
-export type ChatMessageContentItemCacheControlTtl = OpenEnum<typeof ChatMessageContentItemCacheControlTtl>;
-/**
- * Cache control for the content part
- */
-export type ChatMessageContentItemCacheControl = {
-    type: ChatMessageContentItemCacheControlType;
-    ttl?: ChatMessageContentItemCacheControlTtl | undefined;
-};
-/** @internal */
-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 ChatMessageContentItemCacheControlTtl$outboundSchema: z.ZodType<string, ChatMessageContentItemCacheControlTtl>;
-/** @internal */
-export declare const ChatMessageContentItemCacheControl$inboundSchema: z.ZodType<ChatMessageContentItemCacheControl, unknown>;
-/** @internal */
-export type ChatMessageContentItemCacheControl$Outbound = {
-    type: string;
-    ttl?: string | undefined;
-};
-/** @internal */
-export declare const ChatMessageContentItemCacheControl$outboundSchema: z.ZodType<ChatMessageContentItemCacheControl$Outbound, ChatMessageContentItemCacheControl>;
-export declare function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl: ChatMessageContentItemCacheControl): string;
-export declare function chatMessageContentItemCacheControlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemCacheControl, SDKValidationError>;
-//# sourceMappingURL=chatmessagecontentitemcachecontrol.d.ts.map