@openrouter/sdk 0.1.10 → 0.1.13

package/esm/models/operations/createauthkeyscode.js

@@ -4,6 +4,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";
 /**
  * The method used to generate the code challenge
  */
@@ -12,10 +13,7 @@ export const CreateAuthKeysCodeCodeChallengeMethod = {
     Plain: "plain",
 };
 /** @internal */
-export const CreateAuthKeysCodeCodeChallengeMethod$outboundSchema = z.union([
-    z.enum(CreateAuthKeysCodeCodeChallengeMethod),
-    z.string().and(z.custom()),
-]);
+export const CreateAuthKeysCodeCodeChallengeMethod$outboundSchema = openEnums.outboundSchema(CreateAuthKeysCodeCodeChallengeMethod);
 /** @internal */
 export const CreateAuthKeysCodeRequest$outboundSchema = z.object({
     callbackUrl: z.string(),

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

@@ -3,41 +3,38 @@ import { ClosedEnum, 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 Input = string | Array<string> | Array<number> | Array<Array<number>>;
-/**
- * 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.
- */
-export declare const DataCollection: {
-    readonly Deny: "deny";
-    readonly Allow: "allow";
+export declare const TypeImageURL: {
+    readonly ImageUrl: "image_url";
 };
-/**
- * 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.
- */
-export type DataCollection = OpenEnum<typeof DataCollection>;
+export type TypeImageURL = ClosedEnum<typeof TypeImageURL>;
+export type ImageUrl = {
+    url: string;
+};
+export type ContentImageURL = {
+    type: TypeImageURL;
+    imageUrl: ImageUrl;
+};
+export declare const TypeText: {
+    readonly Text: "text";
+};
+export type TypeText = ClosedEnum<typeof TypeText>;
+export type ContentText = {
+    type: TypeText;
+    text: string;
+};
+export type Content = ContentText | ContentImageURL;
+export type Input = {
+    content: Array<ContentText | ContentImageURL>;
+};
+export type InputUnion = string | Array<string> | Array<number> | Array<Array<number>> | Array<Input>;
+export declare const EncodingFormat: {
+    readonly Float: "float";
+    readonly Base64: "base64";
+};
+export type EncodingFormat = OpenEnum<typeof EncodingFormat>;
 export type Order = models.ProviderName | string;
 export type Only = models.ProviderName | string;
 export type Ignore = models.ProviderName | string;
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
-export declare const Sort: {
-    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 Sort = OpenEnum<typeof Sort>;
 /**
  * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
  */
@@ -81,9 +78,10 @@ export type CreateEmbeddingsProvider = {
      *
      * @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;
+    dataCollection?: models.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.
      */
@@ -111,27 +109,20 @@ export type CreateEmbeddingsProvider = {
     /**
      * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
      */
-    sort?: Sort | null | undefined;
+    sort?: models.ProviderSort | 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?: MaxPrice | undefined;
 };
-export declare const EncodingFormatBase64: {
-    readonly Base64: "base64";
-};
-export type EncodingFormatBase64 = ClosedEnum<typeof EncodingFormatBase64>;
-export declare const EncodingFormatFloat: {
-    readonly Float: "float";
-};
-export type EncodingFormatFloat = ClosedEnum<typeof EncodingFormatFloat>;
-export type EncodingFormat = EncodingFormatFloat | EncodingFormatBase64;
 export type CreateEmbeddingsRequest = {
-    input: string | Array<string> | Array<number> | Array<Array<number>>;
+    input: string | Array<string> | Array<number> | Array<Array<number>> | Array<Input>;
     model: string;
-    provider?: CreateEmbeddingsProvider | undefined;
-    encodingFormat?: EncodingFormatFloat | EncodingFormatBase64 | undefined;
+    encodingFormat?: EncodingFormat | undefined;
+    dimensions?: number | undefined;
     user?: string | undefined;
+    provider?: CreateEmbeddingsProvider | undefined;
+    inputType?: string | undefined;
 };
 export declare const ObjectT: {
     readonly List: "list";
@@ -164,12 +155,51 @@ export type CreateEmbeddingsResponseBody = {
 };
 export type CreateEmbeddingsResponse = CreateEmbeddingsResponseBody | string;
 /** @internal */
-export type Input$Outbound = string | Array<string> | Array<number> | Array<Array<number>>;
+export declare const TypeImageURL$outboundSchema: z.ZodEnum<typeof TypeImageURL>;
+/** @internal */
+export type ImageUrl$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const ImageUrl$outboundSchema: z.ZodType<ImageUrl$Outbound, ImageUrl>;
+export declare function imageUrlToJSON(imageUrl: ImageUrl): string;
+/** @internal */
+export type ContentImageURL$Outbound = {
+    type: string;
+    image_url: ImageUrl$Outbound;
+};
+/** @internal */
+export declare const ContentImageURL$outboundSchema: z.ZodType<ContentImageURL$Outbound, ContentImageURL>;
+export declare function contentImageURLToJSON(contentImageURL: ContentImageURL): string;
+/** @internal */
+export declare const TypeText$outboundSchema: z.ZodEnum<typeof TypeText>;
+/** @internal */
+export type ContentText$Outbound = {
+    type: string;
+    text: string;
+};
+/** @internal */
+export declare const ContentText$outboundSchema: z.ZodType<ContentText$Outbound, ContentText>;
+export declare function contentTextToJSON(contentText: ContentText): string;
+/** @internal */
+export type Content$Outbound = ContentText$Outbound | ContentImageURL$Outbound;
+/** @internal */
+export declare const Content$outboundSchema: z.ZodType<Content$Outbound, Content>;
+export declare function contentToJSON(content: Content): string;
+/** @internal */
+export type Input$Outbound = {
+    content: Array<ContentText$Outbound | ContentImageURL$Outbound>;
+};
 /** @internal */
 export declare const Input$outboundSchema: z.ZodType<Input$Outbound, Input>;
 export declare function inputToJSON(input: Input): string;
 /** @internal */
-export declare const DataCollection$outboundSchema: z.ZodType<DataCollection, DataCollection>;
+export type InputUnion$Outbound = string | Array<string> | Array<number> | Array<Array<number>> | Array<Input$Outbound>;
+/** @internal */
+export declare const InputUnion$outboundSchema: z.ZodType<InputUnion$Outbound, InputUnion>;
+export declare function inputUnionToJSON(inputUnion: InputUnion): string;
+/** @internal */
+export declare const EncodingFormat$outboundSchema: z.ZodType<string, EncodingFormat>;
 /** @internal */
 export type Order$Outbound = string | string;
 /** @internal */
@@ -186,8 +216,6 @@ export type Ignore$Outbound = string | string;
 export declare const Ignore$outboundSchema: z.ZodType<Ignore$Outbound, Ignore>;
 export declare function ignoreToJSON(ignore: Ignore): string;
 /** @internal */
-export declare const Sort$outboundSchema: z.ZodType<Sort, Sort>;
-/** @internal */
 export type MaxPrice$Outbound = {
     prompt?: any | undefined;
     completion?: any | undefined;
@@ -216,21 +244,14 @@ export type CreateEmbeddingsProvider$Outbound = {
 export declare const CreateEmbeddingsProvider$outboundSchema: z.ZodType<CreateEmbeddingsProvider$Outbound, CreateEmbeddingsProvider>;
 export declare function createEmbeddingsProviderToJSON(createEmbeddingsProvider: CreateEmbeddingsProvider): string;
 /** @internal */
-export declare const EncodingFormatBase64$outboundSchema: z.ZodEnum<typeof EncodingFormatBase64>;
-/** @internal */
-export declare const EncodingFormatFloat$outboundSchema: z.ZodEnum<typeof EncodingFormatFloat>;
-/** @internal */
-export type EncodingFormat$Outbound = string | string;
-/** @internal */
-export declare const EncodingFormat$outboundSchema: z.ZodType<EncodingFormat$Outbound, EncodingFormat>;
-export declare function encodingFormatToJSON(encodingFormat: EncodingFormat): string;
-/** @internal */
 export type CreateEmbeddingsRequest$Outbound = {
-    input: string | Array<string> | Array<number> | Array<Array<number>>;
+    input: string | Array<string> | Array<number> | Array<Array<number>> | Array<Input$Outbound>;
     model: string;
-    provider?: CreateEmbeddingsProvider$Outbound | undefined;
-    encoding_format?: string | string | undefined;
+    encoding_format?: string | undefined;
+    dimensions?: number | undefined;
     user?: string | undefined;
+    provider?: CreateEmbeddingsProvider$Outbound | undefined;
+    input_type?: string | undefined;
 };
 /** @internal */
 export declare const CreateEmbeddingsRequest$outboundSchema: z.ZodType<CreateEmbeddingsRequest$Outbound, CreateEmbeddingsRequest>;

package/esm/models/operations/createembeddings.js

@@ -4,31 +4,17 @@
 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";
 import * as models from "../index.js";
-/**
- * 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.
- */
-export const DataCollection = {
-    Deny: "deny",
-    Allow: "allow",
+export const TypeImageURL = {
+    ImageUrl: "image_url",
 };
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
-export const Sort = {
-    Price: "price",
-    Throughput: "throughput",
-    Latency: "latency",
+export const TypeText = {
+    Text: "text",
 };
-export const EncodingFormatBase64 = {
-    Base64: "base64",
-};
-export const EncodingFormatFloat = {
+export const EncodingFormat = {
     Float: "float",
+    Base64: "base64",
 };
 export const ObjectT = {
     List: "list",
@@ -37,20 +23,70 @@ export const ObjectEmbedding = {
     Embedding: "embedding",
 };
 /** @internal */
-export const Input$outboundSchema = z.union([
+export const TypeImageURL$outboundSchema = z
+    .enum(TypeImageURL);
+/** @internal */
+export const ImageUrl$outboundSchema = z
+    .object({
+    url: z.string(),
+});
+export function imageUrlToJSON(imageUrl) {
+    return JSON.stringify(ImageUrl$outboundSchema.parse(imageUrl));
+}
+/** @internal */
+export const ContentImageURL$outboundSchema = z.object({
+    type: TypeImageURL$outboundSchema,
+    imageUrl: z.lazy(() => ImageUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function contentImageURLToJSON(contentImageURL) {
+    return JSON.stringify(ContentImageURL$outboundSchema.parse(contentImageURL));
+}
+/** @internal */
+export const TypeText$outboundSchema = z.enum(TypeText);
+/** @internal */
+export const ContentText$outboundSchema = z.object({
+    type: TypeText$outboundSchema,
+    text: z.string(),
+});
+export function contentTextToJSON(contentText) {
+    return JSON.stringify(ContentText$outboundSchema.parse(contentText));
+}
+/** @internal */
+export const Content$outboundSchema = z
+    .union([
+    z.lazy(() => ContentText$outboundSchema),
+    z.lazy(() => ContentImageURL$outboundSchema),
+]);
+export function contentToJSON(content) {
+    return JSON.stringify(Content$outboundSchema.parse(content));
+}
+/** @internal */
+export const Input$outboundSchema = z.object({
+    content: z.array(z.union([
+        z.lazy(() => ContentText$outboundSchema),
+        z.lazy(() => ContentImageURL$outboundSchema),
+    ])),
+});
+export function inputToJSON(input) {
+    return JSON.stringify(Input$outboundSchema.parse(input));
+}
+/** @internal */
+export const InputUnion$outboundSchema = z.union([
     z.string(),
     z.array(z.string()),
     z.array(z.number()),
     z.array(z.array(z.number())),
+    z.array(z.lazy(() => Input$outboundSchema)),
 ]);
-export function inputToJSON(input) {
-    return JSON.stringify(Input$outboundSchema.parse(input));
+export function inputUnionToJSON(inputUnion) {
+    return JSON.stringify(InputUnion$outboundSchema.parse(inputUnion));
 }
 /** @internal */
-export const DataCollection$outboundSchema = z.union([
-    z.enum(DataCollection),
-    z.string().and(z.custom()),
-]);
+export const EncodingFormat$outboundSchema = openEnums.outboundSchema(EncodingFormat);
 /** @internal */
 export const Order$outboundSchema = z.union([
     models.ProviderName$outboundSchema,
@@ -74,11 +110,6 @@ export function ignoreToJSON(ignore) {
     return JSON.stringify(Ignore$outboundSchema.parse(ignore));
 }
 /** @internal */
-export const Sort$outboundSchema = z.union([
-    z.enum(Sort),
-    z.string().and(z.custom()),
-]);
-/** @internal */
 export const MaxPrice$outboundSchema = z
     .object({
     prompt: z.any().optional(),
@@ -94,7 +125,7 @@ export function maxPriceToJSON(maxPrice) {
 export const CreateEmbeddingsProvider$outboundSchema = z.object({
     allowFallbacks: z.nullable(z.boolean()).optional(),
     requireParameters: z.nullable(z.boolean()).optional(),
-    dataCollection: z.nullable(DataCollection$outboundSchema).optional(),
+    dataCollection: z.nullable(models.DataCollection$outboundSchema).optional(),
     zdr: z.nullable(z.boolean()).optional(),
     enforceDistillableText: z.nullable(z.boolean()).optional(),
     order: z.nullable(z.array(z.union([models.ProviderName$outboundSchema, z.string()]))).optional(),
@@ -102,7 +133,7 @@ export const CreateEmbeddingsProvider$outboundSchema = z.object({
     ignore: z.nullable(z.array(z.union([models.ProviderName$outboundSchema, z.string()]))).optional(),
     quantizations: z.nullable(z.array(models.Quantization$outboundSchema))
         .optional(),
-    sort: z.nullable(Sort$outboundSchema).optional(),
+    sort: z.nullable(models.ProviderSort$outboundSchema).optional(),
     maxPrice: z.lazy(() => MaxPrice$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -117,35 +148,24 @@ export function createEmbeddingsProviderToJSON(createEmbeddingsProvider) {
     return JSON.stringify(CreateEmbeddingsProvider$outboundSchema.parse(createEmbeddingsProvider));
 }
 /** @internal */
-export const EncodingFormatBase64$outboundSchema = z.enum(EncodingFormatBase64);
-/** @internal */
-export const EncodingFormatFloat$outboundSchema = z.enum(EncodingFormatFloat);
-/** @internal */
-export const EncodingFormat$outboundSchema = z.union([
-    EncodingFormatFloat$outboundSchema,
-    EncodingFormatBase64$outboundSchema,
-]);
-export function encodingFormatToJSON(encodingFormat) {
-    return JSON.stringify(EncodingFormat$outboundSchema.parse(encodingFormat));
-}
-/** @internal */
 export const CreateEmbeddingsRequest$outboundSchema = z.object({
     input: z.union([
         z.string(),
         z.array(z.string()),
         z.array(z.number()),
         z.array(z.array(z.number())),
+        z.array(z.lazy(() => Input$outboundSchema)),
     ]),
     model: z.string(),
-    provider: z.lazy(() => CreateEmbeddingsProvider$outboundSchema).optional(),
-    encodingFormat: z.union([
-        EncodingFormatFloat$outboundSchema,
-        EncodingFormatBase64$outboundSchema,
-    ]).optional(),
+    encodingFormat: EncodingFormat$outboundSchema.optional(),
+    dimensions: z.int().optional(),
     user: z.string().optional(),
+    provider: z.lazy(() => CreateEmbeddingsProvider$outboundSchema).optional(),
+    inputType: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
         encodingFormat: "encoding_format",
+        inputType: "input_type",
     });
 });
 export function createEmbeddingsRequestToJSON(createEmbeddingsRequest) {

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

@@ -32,7 +32,7 @@ export type CreateKeysRequest = {
      */
     includeByokInLimit?: boolean | undefined;
     /**
-     * Optional ISO 8601 timestamp with timezone when the API key should expire
+     * Optional ISO 8601 UTC timestamp when the API key should expire. Must be UTC, other timezones will be rejected
      */
     expiresAt?: Date | null | undefined;
 };
@@ -131,7 +131,7 @@ export type CreateKeysResponse = {
     key: string;
 };
 /** @internal */
-export declare const CreateKeysLimitReset$outboundSchema: z.ZodType<CreateKeysLimitReset, CreateKeysLimitReset>;
+export declare const CreateKeysLimitReset$outboundSchema: z.ZodType<string, CreateKeysLimitReset>;
 /** @internal */
 export type CreateKeysRequest$Outbound = {
     name: string;

package/esm/models/operations/createkeys.js

@@ -4,6 +4,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";
 /**
  * Type of limit reset for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
  */
@@ -13,10 +14,7 @@ export const CreateKeysLimitReset = {
     Monthly: "monthly",
 };
 /** @internal */
-export const CreateKeysLimitReset$outboundSchema = z.union([
-    z.enum(CreateKeysLimitReset),
-    z.string().and(z.custom()),
-]);
+export const CreateKeysLimitReset$outboundSchema = openEnums.outboundSchema(CreateKeysLimitReset);
 /** @internal */
 export const CreateKeysRequest$outboundSchema = z.object({
     name: z.string(),
@@ -54,7 +52,7 @@ export const CreateKeysData$inboundSchema = z.object({
     byok_usage_monthly: z.number(),
     created_at: z.string(),
     updated_at: z.nullable(z.string()),
-    expires_at: z.nullable(z.string().datetime({ offset: true }).transform(v => new Date(v))).optional(),
+    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
 }).transform((v) => {
     return remap$(v, {
         "limit_remaining": "limitRemaining",

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

@@ -41,7 +41,7 @@ export type ExchangeAuthCodeForAPIKeyResponse = {
     userId: string | null;
 };
 /** @internal */
-export declare const ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema: z.ZodType<ExchangeAuthCodeForAPIKeyCodeChallengeMethod, ExchangeAuthCodeForAPIKeyCodeChallengeMethod>;
+export declare const ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema: z.ZodType<string, ExchangeAuthCodeForAPIKeyCodeChallengeMethod>;
 /** @internal */
 export type ExchangeAuthCodeForAPIKeyRequest$Outbound = {
     code: string;

package/esm/models/operations/exchangeauthcodeforapikey.js

@@ -4,6 +4,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";
 /**
  * The method used to generate the code challenge
  */
@@ -12,10 +13,8 @@ export const ExchangeAuthCodeForAPIKeyCodeChallengeMethod = {
     Plain: "plain",
 };
 /** @internal */
-export const ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema = z.union([
-    z.enum(ExchangeAuthCodeForAPIKeyCodeChallengeMethod),
-    z.string().and(z.custom()),
-]);
+export const ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema = openEnums
+    .outboundSchema(ExchangeAuthCodeForAPIKeyCodeChallengeMethod);
 /** @internal */
 export const ExchangeAuthCodeForAPIKeyRequest$outboundSchema = z.object({
     code: z.string(),

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

@@ -84,6 +84,10 @@ export type GetCurrentKeyData = {
      * Whether to include external BYOK usage in the credit limit
      */
     includeByokInLimit: boolean;
+    /**
+     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
+     */
+    expiresAt?: Date | null | undefined;
     /**
      * Legacy rate limit information about a key. Will always return -1.
      *

package/esm/models/operations/getcurrentkey.js

@@ -30,6 +30,7 @@ export const GetCurrentKeyData$inboundSchema = z.object({
     limit_remaining: z.nullable(z.number()),
     limit_reset: z.nullable(z.string()),
     include_byok_in_limit: z.boolean(),
+    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
     rate_limit: z.lazy(() => RateLimit$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
@@ -45,6 +46,7 @@ export const GetCurrentKeyData$inboundSchema = z.object({
         "limit_remaining": "limitRemaining",
         "limit_reset": "limitReset",
         "include_byok_in_limit": "includeByokInLimit",
+        "expires_at": "expiresAt",
         "rate_limit": "rateLimit",
     });
 });

package/esm/models/operations/getgeneration.js

@@ -4,7 +4,7 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { catchUnrecognizedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
 /**
  * Type of API used for the generation
  */
@@ -20,11 +20,8 @@ export function getGenerationRequestToJSON(getGenerationRequest) {
     return JSON.stringify(GetGenerationRequest$outboundSchema.parse(getGenerationRequest));
 }
 /** @internal */
-export const ApiType$inboundSchema = z
-    .union([
-    z.enum(ApiType),
-    z.string().transform(catchUnrecognizedEnum),
-]);
+export const ApiType$inboundSchema = openEnums
+    .inboundSchema(ApiType);
 /** @internal */
 export const GetGenerationData$inboundSchema = z.object({
     id: z.string(),

package/esm/models/operations/getkey.js

@@ -32,7 +32,7 @@ export const GetKeyData$inboundSchema = z
     byok_usage_monthly: z.number(),
     created_at: z.string(),
     updated_at: z.nullable(z.string()),
-    expires_at: z.nullable(z.string().datetime({ offset: true }).transform(v => new Date(v))).optional(),
+    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
 }).transform((v) => {
     return remap$(v, {
         "limit_remaining": "limitRemaining",

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

@@ -11,22 +11,21 @@ export declare const GetParametersProvider: {
     readonly Alibaba: "Alibaba";
     readonly AmazonBedrock: "Amazon Bedrock";
     readonly Anthropic: "Anthropic";
+    readonly Arcee: "Arcee";
     readonly AtlasCloud: "AtlasCloud";
-    readonly Atoma: "Atoma";
     readonly Avian: "Avian";
     readonly Azure: "Azure";
     readonly BaseTen: "BaseTen";
+    readonly BlackForestLabs: "Black Forest Labs";
     readonly Cerebras: "Cerebras";
     readonly Chutes: "Chutes";
     readonly Cirrascale: "Cirrascale";
     readonly Clarifai: "Clarifai";
     readonly Cloudflare: "Cloudflare";
     readonly Cohere: "Cohere";
-    readonly CrofAI: "CrofAI";
     readonly Crusoe: "Crusoe";
     readonly DeepInfra: "DeepInfra";
     readonly DeepSeek: "DeepSeek";
-    readonly Enfer: "Enfer";
     readonly Featherless: "Featherless";
     readonly Fireworks: "Fireworks";
     readonly Friendli: "Friendli";
@@ -39,11 +38,8 @@ export declare const GetParametersProvider: {
     readonly InferenceNet: "InferenceNet";
     readonly Infermatic: "Infermatic";
     readonly Inflection: "Inflection";
-    readonly Kluster: "Kluster";
-    readonly Lambda: "Lambda";
     readonly Liquid: "Liquid";
     readonly Mancer2: "Mancer 2";
-    readonly Meta: "Meta";
     readonly Minimax: "Minimax";
     readonly ModelRun: "ModelRun";
     readonly Mistral: "Mistral";
@@ -53,7 +49,6 @@ export declare const GetParametersProvider: {
     readonly NCompass: "NCompass";
     readonly Nebius: "Nebius";
     readonly NextBit: "NextBit";
-    readonly Nineteen: "Nineteen";
     readonly Novita: "Novita";
     readonly Nvidia: "Nvidia";
     readonly OpenAI: "OpenAI";
@@ -68,7 +63,6 @@ export declare const GetParametersProvider: {
     readonly Switchpoint: "Switchpoint";
     readonly Targon: "Targon";
     readonly Together: "Together";
-    readonly Ubicloud: "Ubicloud";
     readonly Venice: "Venice";
     readonly WandB: "WandB";
     readonly XAI: "xAI";
@@ -137,7 +131,7 @@ 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<GetParametersProvider, GetParametersProvider>;
+export declare const GetParametersProvider$outboundSchema: z.ZodType<string, GetParametersProvider>;
 /** @internal */
 export type GetParametersRequest$Outbound = {
     author: string;