@openrouter/sdk 0.5.1 → 0.9.11

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

@@ -1,6 +1,36 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type ListProvidersGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+};
+export type ListProvidersRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+};
 export type ListProvidersData = {
     /**
      * Display name of the provider
@@ -30,6 +60,14 @@ export type ListProvidersResponse = {
     data: Array<ListProvidersData>;
 };
 /** @internal */
+export type ListProvidersRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    "X-Title"?: string | undefined;
+};
+/** @internal */
+export declare const ListProvidersRequest$outboundSchema: z.ZodType<ListProvidersRequest$Outbound, ListProvidersRequest>;
+export declare function listProvidersRequestToJSON(listProvidersRequest: ListProvidersRequest): string;
+/** @internal */
 export declare const ListProvidersData$inboundSchema: z.ZodType<ListProvidersData, unknown>;
 export declare function listProvidersDataFromJSON(jsonString: string): SafeParseResult<ListProvidersData, SDKValidationError>;
 /** @internal */

package/esm/models/operations/listproviders.js

@@ -6,6 +6,19 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 /** @internal */
+export const ListProvidersRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    xTitle: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        xTitle: "X-Title",
+    });
+});
+export function listProvidersRequestToJSON(listProvidersRequest) {
+    return JSON.stringify(ListProvidersRequest$outboundSchema.parse(listProvidersRequest));
+}
+/** @internal */
 export const ListProvidersData$inboundSchema = z.object({
     name: z.string(),
     slug: z.string(),

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

@@ -3,7 +3,59 @@ import { EventStream } from "../../lib/event-streams.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
-export type SendChatCompletionRequestResponse = models.ChatResponse | EventStream<models.ChatStreamingResponseChunkData>;
+export type SendChatCompletionRequestGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+};
+export type SendChatCompletionRequestRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+    chatGenerationParams: models.ChatGenerationParams;
+};
+/**
+ * Successful chat completion response
+ */
+export type SendChatCompletionRequestResponseBody = {
+    /**
+     * Streaming chat completion chunk
+     */
+    data: models.ChatStreamingResponseChunk;
+};
+export type SendChatCompletionRequestResponse = models.ChatResponse | EventStream<models.ChatStreamingResponseChunk>;
+/** @internal */
+export type SendChatCompletionRequestRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    "X-Title"?: string | undefined;
+    ChatGenerationParams: models.ChatGenerationParams$Outbound;
+};
+/** @internal */
+export declare const SendChatCompletionRequestRequest$outboundSchema: z.ZodType<SendChatCompletionRequestRequest$Outbound, SendChatCompletionRequestRequest>;
+export declare function sendChatCompletionRequestRequestToJSON(sendChatCompletionRequestRequest: SendChatCompletionRequestRequest): string;
+/** @internal */
+export declare const SendChatCompletionRequestResponseBody$inboundSchema: z.ZodType<SendChatCompletionRequestResponseBody, unknown>;
+export declare function sendChatCompletionRequestResponseBodyFromJSON(jsonString: string): SafeParseResult<SendChatCompletionRequestResponseBody, SDKValidationError>;
 /** @internal */
 export declare const SendChatCompletionRequestResponse$inboundSchema: z.ZodType<SendChatCompletionRequestResponse, unknown>;
 export declare function sendChatCompletionRequestResponseFromJSON(jsonString: string): SafeParseResult<SendChatCompletionRequestResponse, SDKValidationError>;

package/esm/models/operations/sendchatcompletionrequest.js

@@ -4,9 +4,44 @@
  */
 import * as z from "zod/v4";
 import { EventStream } from "../../lib/event-streams.js";
+import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import * as models from "../index.js";
 /** @internal */
+export const SendChatCompletionRequestRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    xTitle: z.string().optional(),
+    chatGenerationParams: models.ChatGenerationParams$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        xTitle: "X-Title",
+        chatGenerationParams: "ChatGenerationParams",
+    });
+});
+export function sendChatCompletionRequestRequestToJSON(sendChatCompletionRequestRequest) {
+    return JSON.stringify(SendChatCompletionRequestRequest$outboundSchema.parse(sendChatCompletionRequestRequest));
+}
+/** @internal */
+export const SendChatCompletionRequestResponseBody$inboundSchema = z.object({
+    data: z.string().transform((v, ctx) => {
+        try {
+            return JSON.parse(v);
+        }
+        catch (err) {
+            ctx.addIssue({
+                input: v,
+                code: "custom",
+                message: `malformed json: ${err}`,
+            });
+            return z.NEVER;
+        }
+    }).pipe(models.ChatStreamingResponseChunk$inboundSchema),
+});
+export function sendChatCompletionRequestResponseBodyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => SendChatCompletionRequestResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'SendChatCompletionRequestResponseBody' from JSON`);
+}
+/** @internal */
 export const SendChatCompletionRequestResponse$inboundSchema = z.union([
     models.ChatResponse$inboundSchema,
     z.custom(x => x instanceof ReadableStream)
@@ -15,8 +50,7 @@ export const SendChatCompletionRequestResponse$inboundSchema = z.union([
             if (rawEvent.data === "[DONE]")
                 return { done: true };
             return {
-                value: models.ChatStreamingResponseChunk$inboundSchema.parse(rawEvent)
-                    ?.data,
+                value: z.lazy(() => SendChatCompletionRequestResponseBody$inboundSchema).parse(rawEvent)?.data,
             };
         });
     }),

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

@@ -2,6 +2,21 @@ 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";
+export type UpdateGuardrailGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+};
 /**
  * Interval at which the limit resets (daily, weekly, monthly)
  */
@@ -45,6 +60,19 @@ export type UpdateGuardrailRequestBody = {
     enforceZdr?: boolean | null | undefined;
 };
 export type UpdateGuardrailRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
     /**
      * The unique identifier of the guardrail to update
      */
@@ -134,6 +162,8 @@ export declare const UpdateGuardrailRequestBody$outboundSchema: z.ZodType<Update
 export declare function updateGuardrailRequestBodyToJSON(updateGuardrailRequestBody: UpdateGuardrailRequestBody): string;
 /** @internal */
 export type UpdateGuardrailRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    "X-Title"?: string | undefined;
     id: string;
     RequestBody: UpdateGuardrailRequestBody$Outbound;
 };

package/esm/models/operations/updateguardrail.js

@@ -48,10 +48,14 @@ export function updateGuardrailRequestBodyToJSON(updateGuardrailRequestBody) {
 }
 /** @internal */
 export const UpdateGuardrailRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    xTitle: z.string().optional(),
     id: z.string(),
     requestBody: z.lazy(() => UpdateGuardrailRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        xTitle: "X-Title",
         requestBody: "RequestBody",
     });
 });

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

@@ -2,6 +2,21 @@ 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";
+export type UpdateKeysGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
+};
 /**
  * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
  */
@@ -37,6 +52,19 @@ export type UpdateKeysRequestBody = {
     includeByokInLimit?: boolean | undefined;
 };
 export type UpdateKeysRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    xTitle?: string | undefined;
     /**
      * The hash identifier of the API key to update
      */
@@ -148,6 +176,8 @@ export declare const UpdateKeysRequestBody$outboundSchema: z.ZodType<UpdateKeysR
 export declare function updateKeysRequestBodyToJSON(updateKeysRequestBody: UpdateKeysRequestBody): string;
 /** @internal */
 export type UpdateKeysRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    "X-Title"?: string | undefined;
     hash: string;
     RequestBody: UpdateKeysRequestBody$Outbound;
 };

package/esm/models/operations/updatekeys.js

@@ -34,10 +34,14 @@ export function updateKeysRequestBodyToJSON(updateKeysRequestBody) {
 }
 /** @internal */
 export const UpdateKeysRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    xTitle: z.string().optional(),
     hash: z.string(),
     requestBody: z.lazy(() => UpdateKeysRequestBody$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        xTitle: "X-Title",
         requestBody: "RequestBody",
     });
 });

package/esm/models/providername.d.ts

@@ -4,6 +4,7 @@ export declare const ProviderName: {
     readonly Ai21: "AI21";
     readonly AionLabs: "AionLabs";
     readonly Alibaba: "Alibaba";
+    readonly Ambient: "Ambient";
     readonly AmazonBedrock: "Amazon Bedrock";
     readonly AmazonNova: "Amazon Nova";
     readonly Anthropic: "Anthropic";
@@ -34,7 +35,9 @@ export declare const ProviderName: {
     readonly Inception: "Inception";
     readonly Inceptron: "Inceptron";
     readonly InferenceNet: "InferenceNet";
+    readonly Ionstream: "Ionstream";
     readonly Infermatic: "Infermatic";
+    readonly IoNet: "Io Net";
     readonly Inflection: "Inflection";
     readonly Liquid: "Liquid";
     readonly Mara: "Mara";
@@ -60,6 +63,7 @@ export declare const ProviderName: {
     readonly Seed: "Seed";
     readonly SiliconFlow: "SiliconFlow";
     readonly Sourceful: "Sourceful";
+    readonly StepFun: "StepFun";
     readonly Stealth: "Stealth";
     readonly StreamLake: "StreamLake";
     readonly Switchpoint: "Switchpoint";

package/esm/models/providername.js

@@ -7,6 +7,7 @@ export const ProviderName = {
     Ai21: "AI21",
     AionLabs: "AionLabs",
     Alibaba: "Alibaba",
+    Ambient: "Ambient",
     AmazonBedrock: "Amazon Bedrock",
     AmazonNova: "Amazon Nova",
     Anthropic: "Anthropic",
@@ -37,7 +38,9 @@ export const ProviderName = {
     Inception: "Inception",
     Inceptron: "Inceptron",
     InferenceNet: "InferenceNet",
+    Ionstream: "Ionstream",
     Infermatic: "Infermatic",
+    IoNet: "Io Net",
     Inflection: "Inflection",
     Liquid: "Liquid",
     Mara: "Mara",
@@ -63,6 +66,7 @@ export const ProviderName = {
     Seed: "Seed",
     SiliconFlow: "SiliconFlow",
     Sourceful: "Sourceful",
+    StepFun: "StepFun",
     Stealth: "Stealth",
     StreamLake: "StreamLake",
     Switchpoint: "Switchpoint",

package/esm/models/providerpreferences.d.ts

@@ -4,66 +4,83 @@ import { DataCollection } from "./datacollection.js";
 import { PreferredMaxLatency, PreferredMaxLatency$Outbound } from "./preferredmaxlatency.js";
 import { PreferredMinThroughput, PreferredMinThroughput$Outbound } from "./preferredminthroughput.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: {
+export declare const ProviderPreferencesSortEnum: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
-export type SortEnum = OpenEnum<typeof SortEnum>;
-export declare const ProviderSortConfigEnum: {
+export type ProviderPreferencesSortEnum = OpenEnum<typeof ProviderPreferencesSortEnum>;
+export declare const ProviderPreferencesProviderSortConfigEnum: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
-export type ProviderSortConfigEnum = ClosedEnum<typeof ProviderSortConfigEnum>;
+export type ProviderPreferencesProviderSortConfigEnum = ClosedEnum<typeof ProviderPreferencesProviderSortConfigEnum>;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export declare const ProviderPreferencesBy: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export type ProviderPreferencesBy = OpenEnum<typeof ProviderPreferencesBy>;
+/**
+ * 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 declare const ProviderPreferencesPartition: {
     readonly Model: "model";
     readonly None: "none";
 };
+/**
+ * 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 type ProviderPreferencesPartition = OpenEnum<typeof ProviderPreferencesPartition>;
 export type ProviderPreferencesProviderSortConfig = {
-    by?: ProviderSort | null | undefined;
+    /**
+     * The provider sorting strategy (price, throughput, latency)
+     */
+    by?: ProviderPreferencesBy | null | undefined;
+    /**
+     * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+     */
     partition?: ProviderPreferencesPartition | null | undefined;
 };
-export type ProviderSortConfigUnion = ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum;
+export type ProviderPreferencesProviderSortConfigUnion = ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export declare const ProviderPreferencesProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
+/**
+ * The provider sorting strategy (price, throughput, 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;
+export type ProviderPreferencesSortUnion = ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum | ProviderPreferencesSortEnum;
 /**
  * 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
+     * Price per million prompt tokens
      */
     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;
 };
 /**
@@ -115,7 +132,7 @@ export type ProviderPreferences = {
      * A list of quantization levels to filter the provider by.
      */
     quantizations?: Array<Quantization> | null | undefined;
-    sort?: ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderSortConfigEnum | SortEnum | null | undefined;
+    sort?: ProviderPreferencesProviderSort | ProviderPreferencesProviderSortConfig | ProviderPreferencesProviderSortConfigEnum | ProviderPreferencesSortEnum | null | undefined;
     /**
      * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
      */
@@ -145,9 +162,11 @@ export type ProviderPreferencesIgnore$Outbound = string | string;
 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>;
+export declare const ProviderPreferencesSortEnum$outboundSchema: z.ZodType<string, ProviderPreferencesSortEnum>;
+/** @internal */
+export declare const ProviderPreferencesProviderSortConfigEnum$outboundSchema: z.ZodEnum<typeof ProviderPreferencesProviderSortConfigEnum>;
 /** @internal */
-export declare const ProviderSortConfigEnum$outboundSchema: z.ZodEnum<typeof ProviderSortConfigEnum>;
+export declare const ProviderPreferencesBy$outboundSchema: z.ZodType<string, ProviderPreferencesBy>;
 /** @internal */
 export declare const ProviderPreferencesPartition$outboundSchema: z.ZodType<string, ProviderPreferencesPartition>;
 /** @internal */
@@ -159,10 +178,10 @@ export type ProviderPreferencesProviderSortConfig$Outbound = {
 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;
+export type ProviderPreferencesProviderSortConfigUnion$Outbound = ProviderPreferencesProviderSortConfig$Outbound | string;
 /** @internal */
-export declare const ProviderSortConfigUnion$outboundSchema: z.ZodType<ProviderSortConfigUnion$Outbound, ProviderSortConfigUnion>;
-export declare function providerSortConfigUnionToJSON(providerSortConfigUnion: ProviderSortConfigUnion): string;
+export declare const ProviderPreferencesProviderSortConfigUnion$outboundSchema: z.ZodType<ProviderPreferencesProviderSortConfigUnion$Outbound, ProviderPreferencesProviderSortConfigUnion>;
+export declare function providerPreferencesProviderSortConfigUnionToJSON(providerPreferencesProviderSortConfigUnion: ProviderPreferencesProviderSortConfigUnion): string;
 /** @internal */
 export declare const ProviderPreferencesProviderSort$outboundSchema: z.ZodType<string, ProviderPreferencesProviderSort>;
 /** @internal */

package/esm/models/providerpreferences.js

@@ -9,22 +9,35 @@ import { DataCollection$outboundSchema, } from "./datacollection.js";
 import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
 import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
 import { ProviderName$outboundSchema } from "./providername.js";
-import { ProviderSort$outboundSchema } from "./providersort.js";
 import { Quantization$outboundSchema } from "./quantization.js";
-export const SortEnum = {
+export const ProviderPreferencesSortEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
 };
-export const ProviderSortConfigEnum = {
+export const ProviderPreferencesProviderSortConfigEnum = {
     Price: "price",
     Throughput: "throughput",
     Latency: "latency",
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ProviderPreferencesBy = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+};
+/**
+ * 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 ProviderPreferencesPartition = {
     Model: "model",
     None: "none",
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export const ProviderPreferencesProviderSort = {
     Price: "price",
     Throughput: "throughput",
@@ -46,27 +59,28 @@ export function providerPreferencesIgnoreToJSON(providerPreferencesIgnore) {
     return JSON.stringify(ProviderPreferencesIgnore$outboundSchema.parse(providerPreferencesIgnore));
 }
 /** @internal */
-export const SortEnum$outboundSchema = openEnums
-    .outboundSchema(SortEnum);
+export const ProviderPreferencesSortEnum$outboundSchema = openEnums.outboundSchema(ProviderPreferencesSortEnum);
+/** @internal */
+export const ProviderPreferencesProviderSortConfigEnum$outboundSchema = z.enum(ProviderPreferencesProviderSortConfigEnum);
 /** @internal */
-export const ProviderSortConfigEnum$outboundSchema = z.enum(ProviderSortConfigEnum);
+export const ProviderPreferencesBy$outboundSchema = openEnums.outboundSchema(ProviderPreferencesBy);
 /** @internal */
 export const ProviderPreferencesPartition$outboundSchema = openEnums.outboundSchema(ProviderPreferencesPartition);
 /** @internal */
 export const ProviderPreferencesProviderSortConfig$outboundSchema = z.object({
-    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    by: z.nullable(ProviderPreferencesBy$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([
+export const ProviderPreferencesProviderSortConfigUnion$outboundSchema = z.union([
     z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-    ProviderSortConfigEnum$outboundSchema,
+    ProviderPreferencesProviderSortConfigEnum$outboundSchema,
 ]);
-export function providerSortConfigUnionToJSON(providerSortConfigUnion) {
-    return JSON.stringify(ProviderSortConfigUnion$outboundSchema.parse(providerSortConfigUnion));
+export function providerPreferencesProviderSortConfigUnionToJSON(providerPreferencesProviderSortConfigUnion) {
+    return JSON.stringify(ProviderPreferencesProviderSortConfigUnion$outboundSchema.parse(providerPreferencesProviderSortConfigUnion));
 }
 /** @internal */
 export const ProviderPreferencesProviderSort$outboundSchema = openEnums.outboundSchema(ProviderPreferencesProviderSort);
@@ -75,9 +89,9 @@ export const ProviderPreferencesSortUnion$outboundSchema = z.union([
     ProviderPreferencesProviderSort$outboundSchema,
     z.union([
         z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-        ProviderSortConfigEnum$outboundSchema,
+        ProviderPreferencesProviderSortConfigEnum$outboundSchema,
     ]),
-    SortEnum$outboundSchema,
+    ProviderPreferencesSortEnum$outboundSchema,
 ]);
 export function providerPreferencesSortUnionToJSON(providerPreferencesSortUnion) {
     return JSON.stringify(ProviderPreferencesSortUnion$outboundSchema.parse(providerPreferencesSortUnion));
@@ -110,9 +124,9 @@ export const ProviderPreferences$outboundSchema = z.object({
         ProviderPreferencesProviderSort$outboundSchema,
         z.union([
             z.lazy(() => ProviderPreferencesProviderSortConfig$outboundSchema),
-            ProviderSortConfigEnum$outboundSchema,
+            ProviderPreferencesProviderSortConfigEnum$outboundSchema,
         ]),
-        SortEnum$outboundSchema,
+        ProviderPreferencesSortEnum$outboundSchema,
     ])).optional(),
     maxPrice: z.lazy(() => ProviderPreferencesMaxPrice$outboundSchema).optional(),
     preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)

package/esm/models/providersort.d.ts

@@ -1,10 +1,16 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export declare const ProviderSort: {
     readonly Price: "price";
     readonly Throughput: "throughput";
     readonly Latency: "latency";
 };
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export type ProviderSort = OpenEnum<typeof ProviderSort>;
 /** @internal */
 export declare const ProviderSort$outboundSchema: z.ZodType<string, ProviderSort>;

package/esm/models/providersort.js

@@ -3,6 +3,9 @@
  * @generated-id: 7d1e919d1ec3
  */
 import * as openEnums from "../types/enums.js";
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
 export const ProviderSort = {
     Price: "price",
     Throughput: "throughput",