@openrouter/sdk 0.2.9 → 0.3.1

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",

package/esm/models/providersortconfig.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { ProviderSort } from "./providersort.js";
+export declare const Partition: {
+    readonly Model: "model";
+    readonly None: "none";
+};
+export type Partition = OpenEnum<typeof Partition>;
+export type ProviderSortConfig = {
+    by?: ProviderSort | null | undefined;
+    partition?: Partition | null | undefined;
+};
+/** @internal */
+export declare const Partition$outboundSchema: z.ZodType<string, Partition>;
+/** @internal */
+export type ProviderSortConfig$Outbound = {
+    by?: string | null | undefined;
+    partition?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderSortConfig$outboundSchema: z.ZodType<ProviderSortConfig$Outbound, ProviderSortConfig>;
+export declare function providerSortConfigToJSON(providerSortConfig: ProviderSortConfig): string;
+//# sourceMappingURL=providersortconfig.d.ts.map

package/esm/models/providersortconfig.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import * as openEnums from "../types/enums.js";
+import { ProviderSort$outboundSchema } from "./providersort.js";
+export const Partition = {
+    Model: "model",
+    None: "none",
+};
+/** @internal */
+export const Partition$outboundSchema = openEnums
+    .outboundSchema(Partition);
+/** @internal */
+export const ProviderSortConfig$outboundSchema = z.object({
+    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    partition: z.nullable(Partition$outboundSchema).optional(),
+});
+export function providerSortConfigToJSON(providerSortConfig) {
+    return JSON.stringify(ProviderSortConfig$outboundSchema.parse(providerSortConfig));
+}
+//# sourceMappingURL=providersortconfig.js.map

package/esm/models/providersortunion.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { ProviderSort } from "./providersort.js";
+import { ProviderSortConfig, ProviderSortConfig$Outbound } from "./providersortconfig.js";
+export type ProviderSortUnion = ProviderSort | ProviderSortConfig;
+/** @internal */
+export type ProviderSortUnion$Outbound = string | ProviderSortConfig$Outbound;
+/** @internal */
+export declare const ProviderSortUnion$outboundSchema: z.ZodType<ProviderSortUnion$Outbound, ProviderSortUnion>;
+export declare function providerSortUnionToJSON(providerSortUnion: ProviderSortUnion): string;
+//# sourceMappingURL=providersortunion.d.ts.map

package/esm/models/providersortunion.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { ProviderSort$outboundSchema } from "./providersort.js";
+import { ProviderSortConfig$outboundSchema, } from "./providersortconfig.js";
+/** @internal */
+export const ProviderSortUnion$outboundSchema = z.union([ProviderSort$outboundSchema, ProviderSortConfig$outboundSchema]);
+export function providerSortUnionToJSON(providerSortUnion) {
+    return JSON.stringify(ProviderSortUnion$outboundSchema.parse(providerSortUnion));
+}
+//# sourceMappingURL=providersortunion.js.map

package/esm/models/publicendpoint.d.ts

@@ -7,53 +7,53 @@ import { Parameter } from "./parameter.js";
 import { ProviderName } from "./providername.js";
 export type Pricing = {
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    prompt?: any | undefined;
+    prompt: string;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    completion?: any | undefined;
+    completion: string;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    request?: any | undefined;
+    request?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    image?: any | undefined;
+    image?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    imageToken?: any | undefined;
+    imageToken?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    imageOutput?: any | undefined;
+    imageOutput?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    audio?: any | undefined;
+    audio?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    inputAudioCache?: any | undefined;
+    inputAudioCache?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    webSearch?: any | undefined;
+    webSearch?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    internalReasoning?: any | undefined;
+    internalReasoning?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    inputCacheRead?: any | undefined;
+    inputCacheRead?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    inputCacheWrite?: any | undefined;
+    inputCacheWrite?: string | undefined;
     discount?: number | undefined;
 };
 export declare const PublicEndpointQuantization: {

package/esm/models/publicendpoint.js

@@ -21,18 +21,18 @@ export const PublicEndpointQuantization = {
 };
 /** @internal */
 export const Pricing$inboundSchema = z.object({
-    prompt: z.any().optional(),
-    completion: z.any().optional(),
-    request: z.any().optional(),
-    image: z.any().optional(),
-    image_token: z.any().optional(),
-    image_output: z.any().optional(),
-    audio: z.any().optional(),
-    input_audio_cache: z.any().optional(),
-    web_search: z.any().optional(),
-    internal_reasoning: z.any().optional(),
-    input_cache_read: z.any().optional(),
-    input_cache_write: z.any().optional(),
+    prompt: z.string(),
+    completion: z.string(),
+    request: z.string().optional(),
+    image: z.string().optional(),
+    image_token: z.string().optional(),
+    image_output: z.string().optional(),
+    audio: z.string().optional(),
+    input_audio_cache: z.string().optional(),
+    web_search: z.string().optional(),
+    internal_reasoning: z.string().optional(),
+    input_cache_read: z.string().optional(),
+    input_cache_write: z.string().optional(),
     discount: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/publicpricing.d.ts

@@ -6,53 +6,53 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export type PublicPricing = {
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    prompt?: any | undefined;
+    prompt: string;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    completion?: any | undefined;
+    completion: string;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    request?: any | undefined;
+    request?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    image?: any | undefined;
+    image?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    imageToken?: any | undefined;
+    imageToken?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    imageOutput?: any | undefined;
+    imageOutput?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    audio?: any | undefined;
+    audio?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    inputAudioCache?: any | undefined;
+    inputAudioCache?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    webSearch?: any | undefined;
+    webSearch?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    internalReasoning?: any | undefined;
+    internalReasoning?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    inputCacheRead?: any | undefined;
+    inputCacheRead?: string | undefined;
     /**
-     * A value in string or number format that is a large number
+     * A value in string format that is a large number
      */
-    inputCacheWrite?: any | undefined;
+    inputCacheWrite?: string | undefined;
     discount?: number | undefined;
 };
 /** @internal */