@openrouter/sdk 0.2.11 → 0.3.1

package/esm/models/operations/getparameters.d.ts

@@ -2,85 +2,14 @@ import * as z from "zod/v4";
 import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
 export type GetParametersSecurity = {
     bearer: string;
 };
-export declare const GetParametersProvider: {
-    readonly Ai21: "AI21";
-    readonly AionLabs: "AionLabs";
-    readonly Alibaba: "Alibaba";
-    readonly AmazonBedrock: "Amazon Bedrock";
-    readonly AmazonNova: "Amazon Nova";
-    readonly Anthropic: "Anthropic";
-    readonly ArceeAI: "Arcee AI";
-    readonly AtlasCloud: "AtlasCloud";
-    readonly Avian: "Avian";
-    readonly Azure: "Azure";
-    readonly BaseTen: "BaseTen";
-    readonly BytePlus: "BytePlus";
-    readonly BlackForestLabs: "Black Forest Labs";
-    readonly Cerebras: "Cerebras";
-    readonly Chutes: "Chutes";
-    readonly Cirrascale: "Cirrascale";
-    readonly Clarifai: "Clarifai";
-    readonly Cloudflare: "Cloudflare";
-    readonly Cohere: "Cohere";
-    readonly Crusoe: "Crusoe";
-    readonly DeepInfra: "DeepInfra";
-    readonly DeepSeek: "DeepSeek";
-    readonly Featherless: "Featherless";
-    readonly Fireworks: "Fireworks";
-    readonly Friendli: "Friendli";
-    readonly GMICloud: "GMICloud";
-    readonly GoPomelo: "GoPomelo";
-    readonly Google: "Google";
-    readonly GoogleAIStudio: "Google AI Studio";
-    readonly Groq: "Groq";
-    readonly Hyperbolic: "Hyperbolic";
-    readonly Inception: "Inception";
-    readonly InferenceNet: "InferenceNet";
-    readonly Infermatic: "Infermatic";
-    readonly Inflection: "Inflection";
-    readonly Liquid: "Liquid";
-    readonly Mara: "Mara";
-    readonly Mancer2: "Mancer 2";
-    readonly Minimax: "Minimax";
-    readonly ModelRun: "ModelRun";
-    readonly Mistral: "Mistral";
-    readonly Modular: "Modular";
-    readonly MoonshotAI: "Moonshot AI";
-    readonly Morph: "Morph";
-    readonly NCompass: "NCompass";
-    readonly Nebius: "Nebius";
-    readonly NextBit: "NextBit";
-    readonly Novita: "Novita";
-    readonly Nvidia: "Nvidia";
-    readonly OpenAI: "OpenAI";
-    readonly OpenInference: "OpenInference";
-    readonly Parasail: "Parasail";
-    readonly Perplexity: "Perplexity";
-    readonly Phala: "Phala";
-    readonly Relace: "Relace";
-    readonly SambaNova: "SambaNova";
-    readonly SiliconFlow: "SiliconFlow";
-    readonly Sourceful: "Sourceful";
-    readonly Stealth: "Stealth";
-    readonly StreamLake: "StreamLake";
-    readonly Switchpoint: "Switchpoint";
-    readonly Targon: "Targon";
-    readonly Together: "Together";
-    readonly Venice: "Venice";
-    readonly WandB: "WandB";
-    readonly Xiaomi: "Xiaomi";
-    readonly XAI: "xAI";
-    readonly ZAi: "Z.AI";
-    readonly FakeProvider: "FakeProvider";
-};
-export type GetParametersProvider = OpenEnum<typeof GetParametersProvider>;
 export type GetParametersRequest = {
     author: string;
     slug: string;
-    provider?: GetParametersProvider | undefined;
+    provider?: models.ProviderName | undefined;
 };
 export declare const SupportedParameter: {
     readonly Temperature: "temperature";
@@ -104,6 +33,7 @@ export declare const SupportedParameter: {
     readonly ParallelToolCalls: "parallel_tool_calls";
     readonly IncludeReasoning: "include_reasoning";
     readonly Reasoning: "reasoning";
+    readonly ReasoningEffort: "reasoning_effort";
     readonly WebSearchOptions: "web_search_options";
     readonly Verbosity: "verbosity";
 };
@@ -138,8 +68,6 @@ export type GetParametersSecurity$Outbound = {
 export declare const GetParametersSecurity$outboundSchema: z.ZodType<GetParametersSecurity$Outbound, GetParametersSecurity>;
 export declare function getParametersSecurityToJSON(getParametersSecurity: GetParametersSecurity): string;
 /** @internal */
-export declare const GetParametersProvider$outboundSchema: z.ZodType<string, GetParametersProvider>;
-/** @internal */
 export type GetParametersRequest$Outbound = {
     author: string;
     slug: string;

package/esm/models/operations/getparameters.js

@@ -5,77 +5,7 @@ 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 GetParametersProvider = {
-    Ai21: "AI21",
-    AionLabs: "AionLabs",
-    Alibaba: "Alibaba",
-    AmazonBedrock: "Amazon Bedrock",
-    AmazonNova: "Amazon Nova",
-    Anthropic: "Anthropic",
-    ArceeAI: "Arcee AI",
-    AtlasCloud: "AtlasCloud",
-    Avian: "Avian",
-    Azure: "Azure",
-    BaseTen: "BaseTen",
-    BytePlus: "BytePlus",
-    BlackForestLabs: "Black Forest Labs",
-    Cerebras: "Cerebras",
-    Chutes: "Chutes",
-    Cirrascale: "Cirrascale",
-    Clarifai: "Clarifai",
-    Cloudflare: "Cloudflare",
-    Cohere: "Cohere",
-    Crusoe: "Crusoe",
-    DeepInfra: "DeepInfra",
-    DeepSeek: "DeepSeek",
-    Featherless: "Featherless",
-    Fireworks: "Fireworks",
-    Friendli: "Friendli",
-    GMICloud: "GMICloud",
-    GoPomelo: "GoPomelo",
-    Google: "Google",
-    GoogleAIStudio: "Google AI Studio",
-    Groq: "Groq",
-    Hyperbolic: "Hyperbolic",
-    Inception: "Inception",
-    InferenceNet: "InferenceNet",
-    Infermatic: "Infermatic",
-    Inflection: "Inflection",
-    Liquid: "Liquid",
-    Mara: "Mara",
-    Mancer2: "Mancer 2",
-    Minimax: "Minimax",
-    ModelRun: "ModelRun",
-    Mistral: "Mistral",
-    Modular: "Modular",
-    MoonshotAI: "Moonshot AI",
-    Morph: "Morph",
-    NCompass: "NCompass",
-    Nebius: "Nebius",
-    NextBit: "NextBit",
-    Novita: "Novita",
-    Nvidia: "Nvidia",
-    OpenAI: "OpenAI",
-    OpenInference: "OpenInference",
-    Parasail: "Parasail",
-    Perplexity: "Perplexity",
-    Phala: "Phala",
-    Relace: "Relace",
-    SambaNova: "SambaNova",
-    SiliconFlow: "SiliconFlow",
-    Sourceful: "Sourceful",
-    Stealth: "Stealth",
-    StreamLake: "StreamLake",
-    Switchpoint: "Switchpoint",
-    Targon: "Targon",
-    Together: "Together",
-    Venice: "Venice",
-    WandB: "WandB",
-    Xiaomi: "Xiaomi",
-    XAI: "xAI",
-    ZAi: "Z.AI",
-    FakeProvider: "FakeProvider",
-};
+import * as models from "../index.js";
 export const SupportedParameter = {
     Temperature: "temperature",
     TopP: "top_p",
@@ -98,6 +28,7 @@ export const SupportedParameter = {
     ParallelToolCalls: "parallel_tool_calls",
     IncludeReasoning: "include_reasoning",
     Reasoning: "reasoning",
+    ReasoningEffort: "reasoning_effort",
     WebSearchOptions: "web_search_options",
     Verbosity: "verbosity",
 };
@@ -109,12 +40,10 @@ export function getParametersSecurityToJSON(getParametersSecurity) {
     return JSON.stringify(GetParametersSecurity$outboundSchema.parse(getParametersSecurity));
 }
 /** @internal */
-export const GetParametersProvider$outboundSchema = openEnums.outboundSchema(GetParametersProvider);
-/** @internal */
 export const GetParametersRequest$outboundSchema = z.object({
     author: z.string(),
     slug: z.string(),
-    provider: GetParametersProvider$outboundSchema.optional(),
+    provider: models.ProviderName$outboundSchema.optional(),
 });
 export function getParametersRequestToJSON(getParametersRequest) {
     return JSON.stringify(GetParametersRequest$outboundSchema.parse(getParametersRequest));

package/esm/models/parameter.d.ts

@@ -22,6 +22,7 @@ export declare const Parameter: {
     readonly ParallelToolCalls: "parallel_tool_calls";
     readonly IncludeReasoning: "include_reasoning";
     readonly Reasoning: "reasoning";
+    readonly ReasoningEffort: "reasoning_effort";
     readonly WebSearchOptions: "web_search_options";
     readonly Verbosity: "verbosity";
 };

package/esm/models/parameter.js

@@ -24,6 +24,7 @@ export const Parameter = {
     ParallelToolCalls: "parallel_tool_calls",
     IncludeReasoning: "include_reasoning",
     Reasoning: "reasoning",
+    ReasoningEffort: "reasoning_effort",
     WebSearchOptions: "web_search_options",
     Verbosity: "verbosity",
 };

package/esm/models/pdfparserengine.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * The engine to use for parsing PDF files.
+ */
+export declare const PDFParserEngine: {
+    readonly MistralOcr: "mistral-ocr";
+    readonly PdfText: "pdf-text";
+    readonly Native: "native";
+};
+/**
+ * The engine to use for parsing PDF files.
+ */
+export type PDFParserEngine = OpenEnum<typeof PDFParserEngine>;
+/** @internal */
+export declare const PDFParserEngine$outboundSchema: z.ZodType<string, PDFParserEngine>;
+//# sourceMappingURL=pdfparserengine.d.ts.map

package/esm/models/pdfparserengine.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * The engine to use for parsing PDF files.
+ */
+export const PDFParserEngine = {
+    MistralOcr: "mistral-ocr",
+    PdfText: "pdf-text",
+    Native: "native",
+};
+/** @internal */
+export const PDFParserEngine$outboundSchema = openEnums.outboundSchema(PDFParserEngine);
+//# sourceMappingURL=pdfparserengine.js.map

package/esm/models/pdfparseroptions.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { PDFParserEngine } from "./pdfparserengine.js";
+/**
+ * Options for PDF parsing.
+ */
+export type PDFParserOptions = {
+    /**
+     * The engine to use for parsing PDF files.
+     */
+    engine?: PDFParserEngine | undefined;
+};
+/** @internal */
+export type PDFParserOptions$Outbound = {
+    engine?: string | undefined;
+};
+/** @internal */
+export declare const PDFParserOptions$outboundSchema: z.ZodType<PDFParserOptions$Outbound, PDFParserOptions>;
+export declare function pdfParserOptionsToJSON(pdfParserOptions: PDFParserOptions): string;
+//# sourceMappingURL=pdfparseroptions.d.ts.map

package/esm/models/pdfparseroptions.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { PDFParserEngine$outboundSchema, } from "./pdfparserengine.js";
+/** @internal */
+export const PDFParserOptions$outboundSchema = z.object({
+    engine: PDFParserEngine$outboundSchema.optional(),
+});
+export function pdfParserOptionsToJSON(pdfParserOptions) {
+    return JSON.stringify(PDFParserOptions$outboundSchema.parse(pdfParserOptions));
+}
+//# sourceMappingURL=pdfparseroptions.js.map

package/esm/models/providerpreferences.d.ts

@@ -0,0 +1,215 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { DataCollection } from "./datacollection.js";
+import { ProviderName } from "./providername.js";
+import { ProviderSort } from "./providersort.js";
+import { Quantization } from "./quantization.js";
+export type ProviderPreferencesOrder = ProviderName | string;
+export type ProviderPreferencesOnly = ProviderName | string;
+export type ProviderPreferencesIgnore = ProviderName | string;
+export declare const SortEnum: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+export type SortEnum = OpenEnum<typeof SortEnum>;
+export declare const ProviderSortConfigEnum: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+export type ProviderSortConfigEnum = ClosedEnum<typeof ProviderSortConfigEnum>;
+export declare const ProviderPreferencesPartition: {
+    readonly Model: "model";
+    readonly None: "none";
+};
+export type ProviderPreferencesPartition = OpenEnum<typeof ProviderPreferencesPartition>;
+export type ProviderPreferencesProviderSortConfig = {
+    by?: ProviderSort | null | undefined;
+    partition?: ProviderPreferencesPartition | null | undefined;
+};
+export type ProviderSortConfigUnion = ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum;
+export declare const ProviderPreferencesProviderSort: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+export type ProviderPreferencesProviderSort = OpenEnum<typeof ProviderPreferencesProviderSort>;
+/**
+ * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
+ */
+export type ProviderPreferencesSortUnion = ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum | SortEnum;
+/**
+ * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
+ */
+export type ProviderPreferencesMaxPrice = {
+    /**
+     * A value in string format that is a large number
+     */
+    prompt?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    completion?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    image?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    audio?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    request?: string | undefined;
+};
+/**
+ * Provider routing preferences for the request.
+ */
+export type ProviderPreferences = {
+    /**
+     * Whether to allow backup providers to serve requests
+     *
+     * @remarks
+     * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
+     * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
+     */
+    allowFallbacks?: boolean | null | undefined;
+    /**
+     * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
+     */
+    requireParameters?: boolean | null | undefined;
+    /**
+     * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+     *
+     * @remarks
+     * - allow: (default) allow providers which store user data non-transiently and may train on it
+     *
+     * - deny: use only providers which do not collect user data.
+     */
+    dataCollection?: DataCollection | null | undefined;
+    /**
+     * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
+     */
+    zdr?: boolean | null | undefined;
+    /**
+     * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
+     */
+    enforceDistillableText?: boolean | null | undefined;
+    /**
+     * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
+     */
+    order?: Array<ProviderName | string> | null | undefined;
+    /**
+     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
+     */
+    only?: Array<ProviderName | string> | null | undefined;
+    /**
+     * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
+     */
+    ignore?: Array<ProviderName | string> | null | undefined;
+    /**
+     * A list of quantization levels to filter the provider by.
+     */
+    quantizations?: Array<Quantization> | null | undefined;
+    sort?: ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum | SortEnum | null | undefined;
+    /**
+     * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
+     */
+    maxPrice?: ProviderPreferencesMaxPrice | undefined;
+    /**
+     * Preferred minimum throughput (in tokens per second). Endpoints below this threshold may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     */
+    preferredMinThroughput?: number | null | undefined;
+    /**
+     * Preferred maximum latency (in seconds). Endpoints above this threshold may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     */
+    preferredMaxLatency?: number | null | undefined;
+    /**
+     * **DEPRECATED** Use preferred_min_throughput instead. Backwards-compatible alias for preferred_min_throughput.
+     *
+     * @deprecated field: Use preferred_min_throughput instead..
+     */
+    minThroughput?: number | null | undefined;
+    /**
+     * **DEPRECATED** Use preferred_max_latency instead. Backwards-compatible alias for preferred_max_latency.
+     *
+     * @deprecated field: Use preferred_max_latency instead..
+     */
+    maxLatency?: number | null | undefined;
+};
+/** @internal */
+export type ProviderPreferencesOrder$Outbound = string | string;
+/** @internal */
+export declare const ProviderPreferencesOrder$outboundSchema: z.ZodType<ProviderPreferencesOrder$Outbound, ProviderPreferencesOrder>;
+export declare function providerPreferencesOrderToJSON(providerPreferencesOrder: ProviderPreferencesOrder): string;
+/** @internal */
+export type ProviderPreferencesOnly$Outbound = string | string;
+/** @internal */
+export declare const ProviderPreferencesOnly$outboundSchema: z.ZodType<ProviderPreferencesOnly$Outbound, ProviderPreferencesOnly>;
+export declare function providerPreferencesOnlyToJSON(providerPreferencesOnly: ProviderPreferencesOnly): string;
+/** @internal */
+export type ProviderPreferencesIgnore$Outbound = string | string;
+/** @internal */
+export declare const ProviderPreferencesIgnore$outboundSchema: z.ZodType<ProviderPreferencesIgnore$Outbound, ProviderPreferencesIgnore>;
+export declare function providerPreferencesIgnoreToJSON(providerPreferencesIgnore: ProviderPreferencesIgnore): string;
+/** @internal */
+export declare const SortEnum$outboundSchema: z.ZodType<string, SortEnum>;
+/** @internal */
+export declare const ProviderSortConfigEnum$outboundSchema: z.ZodEnum<typeof ProviderSortConfigEnum>;
+/** @internal */
+export declare const ProviderPreferencesPartition$outboundSchema: z.ZodType<string, ProviderPreferencesPartition>;
+/** @internal */
+export type ProviderPreferencesProviderSortConfig$Outbound = {
+    by?: string | null | undefined;
+    partition?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderPreferencesProviderSortConfig$outboundSchema: z.ZodType<ProviderPreferencesProviderSortConfig$Outbound, ProviderPreferencesProviderSortConfig>;
+export declare function providerPreferencesProviderSortConfigToJSON(providerPreferencesProviderSortConfig: ProviderPreferencesProviderSortConfig): string;
+/** @internal */
+export type ProviderSortConfigUnion$Outbound = ProviderPreferencesProviderSortConfig$Outbound | string;
+/** @internal */
+export declare const ProviderSortConfigUnion$outboundSchema: z.ZodType<ProviderSortConfigUnion$Outbound, ProviderSortConfigUnion>;
+export declare function providerSortConfigUnionToJSON(providerSortConfigUnion: ProviderSortConfigUnion): string;
+/** @internal */
+export declare const ProviderPreferencesProviderSort$outboundSchema: z.ZodType<string, ProviderPreferencesProviderSort>;
+/** @internal */
+export type ProviderPreferencesSortUnion$Outbound = string | ProviderPreferencesProviderSortConfig$Outbound | string | string;
+/** @internal */
+export declare const ProviderPreferencesSortUnion$outboundSchema: z.ZodType<ProviderPreferencesSortUnion$Outbound, ProviderPreferencesSortUnion>;
+export declare function providerPreferencesSortUnionToJSON(providerPreferencesSortUnion: ProviderPreferencesSortUnion): string;
+/** @internal */
+export type ProviderPreferencesMaxPrice$Outbound = {
+    prompt?: string | undefined;
+    completion?: string | undefined;
+    image?: string | undefined;
+    audio?: string | undefined;
+    request?: string | undefined;
+};
+/** @internal */
+export declare const ProviderPreferencesMaxPrice$outboundSchema: z.ZodType<ProviderPreferencesMaxPrice$Outbound, ProviderPreferencesMaxPrice>;
+export declare function providerPreferencesMaxPriceToJSON(providerPreferencesMaxPrice: ProviderPreferencesMaxPrice): string;
+/** @internal */
+export type ProviderPreferences$Outbound = {
+    allow_fallbacks?: boolean | null | undefined;
+    require_parameters?: boolean | null | undefined;
+    data_collection?: string | null | undefined;
+    zdr?: boolean | null | undefined;
+    enforce_distillable_text?: boolean | null | undefined;
+    order?: Array<string | string> | null | undefined;
+    only?: Array<string | string> | null | undefined;
+    ignore?: Array<string | string> | null | undefined;
+    quantizations?: Array<string> | null | undefined;
+    sort?: string | ProviderPreferencesProviderSortConfig$Outbound | string | string | null | undefined;
+    max_price?: ProviderPreferencesMaxPrice$Outbound | undefined;
+    preferred_min_throughput?: number | null | undefined;
+    preferred_max_latency?: number | null | undefined;
+    min_throughput?: number | null | undefined;
+    max_latency?: number | null | undefined;
+};
+/** @internal */
+export declare const ProviderPreferences$outboundSchema: z.ZodType<ProviderPreferences$Outbound, ProviderPreferences>;
+export declare function providerPreferencesToJSON(providerPreferences: ProviderPreferences): string;
+//# sourceMappingURL=providerpreferences.d.ts.map

package/esm/models/providerpreferences.js

@@ -0,0 +1,135 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { DataCollection$outboundSchema, } from "./datacollection.js";
+import { ProviderName$outboundSchema } from "./providername.js";
+import { ProviderSort$outboundSchema } from "./providersort.js";
+import { Quantization$outboundSchema } from "./quantization.js";
+export const SortEnum = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+export const ProviderSortConfigEnum = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+export const ProviderPreferencesPartition = {
+    Model: "model",
+    None: "none",
+};
+export const ProviderPreferencesProviderSort = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+/** @internal */
+export const ProviderPreferencesOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function providerPreferencesOrderToJSON(providerPreferencesOrder) {
+    return JSON.stringify(ProviderPreferencesOrder$outboundSchema.parse(providerPreferencesOrder));
+}
+/** @internal */
+export const ProviderPreferencesOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function providerPreferencesOnlyToJSON(providerPreferencesOnly) {
+    return JSON.stringify(ProviderPreferencesOnly$outboundSchema.parse(providerPreferencesOnly));
+}
+/** @internal */
+export const ProviderPreferencesIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function providerPreferencesIgnoreToJSON(providerPreferencesIgnore) {
+    return JSON.stringify(ProviderPreferencesIgnore$outboundSchema.parse(providerPreferencesIgnore));
+}
+/** @internal */
+export const SortEnum$outboundSchema = openEnums
+    .outboundSchema(SortEnum);
+/** @internal */
+export const ProviderSortConfigEnum$outboundSchema = z.enum(ProviderSortConfigEnum);
+/** @internal */
+export const ProviderPreferencesPartition$outboundSchema = openEnums.outboundSchema(ProviderPreferencesPartition);
+/** @internal */
+export const ProviderPreferencesProviderSortConfig$outboundSchema = z.object({
+    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    partition: z.nullable(ProviderPreferencesPartition$outboundSchema).optional(),
+});
+export function providerPreferencesProviderSortConfigToJSON(providerPreferencesProviderSortConfig) {
+    return JSON.stringify(ProviderPreferencesProviderSortConfig$outboundSchema.parse(providerPreferencesProviderSortConfig));
+}
+/** @internal */
+export const ProviderSortConfigUnion$outboundSchema = z.union([
+    z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
+    ProviderSortConfigEnum$outboundSchema,
+]);
+export function providerSortConfigUnionToJSON(providerSortConfigUnion) {
+    return JSON.stringify(ProviderSortConfigUnion$outboundSchema.parse(providerSortConfigUnion));
+}
+/** @internal */
+export const ProviderPreferencesProviderSort$outboundSchema = openEnums.outboundSchema(ProviderPreferencesProviderSort);
+/** @internal */
+export const ProviderPreferencesSortUnion$outboundSchema = z.union([
+    ProviderPreferencesProviderSort$outboundSchema,
+    z.union([
+        z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
+        ProviderSortConfigEnum$outboundSchema,
+    ]),
+    SortEnum$outboundSchema,
+]);
+export function providerPreferencesSortUnionToJSON(providerPreferencesSortUnion) {
+    return JSON.stringify(ProviderPreferencesSortUnion$outboundSchema.parse(providerPreferencesSortUnion));
+}
+/** @internal */
+export const ProviderPreferencesMaxPrice$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 providerPreferencesMaxPriceToJSON(providerPreferencesMaxPrice) {
+    return JSON.stringify(ProviderPreferencesMaxPrice$outboundSchema.parse(providerPreferencesMaxPrice));
+}
+/** @internal */
+export const ProviderPreferences$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([
+        ProviderPreferencesProviderSort$outboundSchema,
+        z.union([
+            z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
+            ProviderSortConfigEnum$outboundSchema,
+        ]),
+        SortEnum$outboundSchema,
+    ])).optional(),
+    maxPrice: z.lazy(() => ProviderPreferencesMaxPrice$outboundSchema).optional(),
+    preferredMinThroughput: z.nullable(z.number()).optional(),
+    preferredMaxLatency: z.nullable(z.number()).optional(),
+    minThroughput: z.nullable(z.number()).optional(),
+    maxLatency: z.nullable(z.number()).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",
+        minThroughput: "min_throughput",
+        maxLatency: "max_latency",
+    });
+});
+export function providerPreferencesToJSON(providerPreferences) {
+    return JSON.stringify(ProviderPreferences$outboundSchema.parse(providerPreferences));
+}
+//# sourceMappingURL=providerpreferences.js.map

package/esm/models/providersort.d.ts

@@ -1,16 +1,10 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
 export declare const ProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
 export type ProviderSort = OpenEnum<typeof ProviderSort>;
 /** @internal */
 export declare const ProviderSort$outboundSchema: z.ZodType<string, ProviderSort>;

package/esm/models/providersort.js

@@ -2,9 +2,6 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as openEnums from "../types/enums.js";
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
 export const ProviderSort = {
     Price: "price",
     Throughput: "throughput",