@openrouter/sdk 0.1.11 → 0.1.13

package/esm/models/openresponsesrequest.js

@@ -4,6 +4,7 @@
 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 { OpenAIResponsesIncludable$outboundSchema, } from "./openairesponsesincludable.js";
 import { OpenAIResponsesPrompt$outboundSchema, } from "./openairesponsesprompt.js";
 import { OpenAIResponsesToolChoiceUnion$outboundSchema, } from "./openairesponsestoolchoiceunion.js";
@@ -15,6 +16,7 @@ import { OpenResponsesWebSearchPreview20250311Tool$outboundSchema, } from "./ope
 import { OpenResponsesWebSearchPreviewTool$outboundSchema, } from "./openresponseswebsearchpreviewtool.js";
 import { OpenResponsesWebSearchTool$outboundSchema, } from "./openresponseswebsearchtool.js";
 import { ProviderName$outboundSchema } from "./providername.js";
+import { ProviderSort$outboundSchema } from "./providersort.js";
 import { Quantization$outboundSchema } from "./quantization.js";
 export const OpenResponsesRequestType = {
     Function: "function",
@@ -30,25 +32,6 @@ export const Truncation = {
     Auto: "auto",
     Disabled: "disabled",
 };
-/**
- * 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",
-};
-/**
- * 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 IdFileParser = {
     FileParser: "file-parser",
 };
@@ -96,8 +79,6 @@ export const ServiceTier$outboundSchema = openEnums.outboundSchema(ServiceTier);
 /** @internal */
 export const Truncation$outboundSchema = openEnums.outboundSchema(Truncation);
 /** @internal */
-export const DataCollection$outboundSchema = openEnums.outboundSchema(DataCollection);
-/** @internal */
 export const Order$outboundSchema = z.union([
     ProviderName$outboundSchema,
     z.string(),
@@ -120,9 +101,6 @@ export function ignoreToJSON(ignore) {
     return JSON.stringify(Ignore$outboundSchema.parse(ignore));
 }
 /** @internal */
-export const Sort$outboundSchema = openEnums
-    .outboundSchema(Sort);
-/** @internal */
 export const MaxPrice$outboundSchema = z
     .object({
     prompt: z.any().optional(),
@@ -146,7 +124,7 @@ export const Provider$outboundSchema = z
     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(Sort$outboundSchema).optional(),
+    sort: z.nullable(ProviderSort$outboundSchema).optional(),
     maxPrice: z.lazy(() => MaxPrice$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {

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

@@ -6,30 +6,15 @@ 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",
@@ -38,17 +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 = openEnums.outboundSchema(DataCollection);
+export const EncodingFormat$outboundSchema = openEnums.outboundSchema(EncodingFormat);
 /** @internal */
 export const Order$outboundSchema = z.union([
     models.ProviderName$outboundSchema,
@@ -72,9 +110,6 @@ export function ignoreToJSON(ignore) {
     return JSON.stringify(Ignore$outboundSchema.parse(ignore));
 }
 /** @internal */
-export const Sort$outboundSchema = openEnums
-    .outboundSchema(Sort);
-/** @internal */
 export const MaxPrice$outboundSchema = z
     .object({
     prompt: z.any().optional(),
@@ -90,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(),
@@ -98,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, {
@@ -113,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.js

@@ -52,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/getcurrentkey.js

@@ -30,7 +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.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(),
     rate_limit: z.lazy(() => RateLimit$inboundSchema),
 }).transform((v) => {
     return remap$(v, {

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

package/esm/models/operations/getparameters.js

@@ -11,22 +11,21 @@ export const GetParametersProvider = {
     Alibaba: "Alibaba",
     AmazonBedrock: "Amazon Bedrock",
     Anthropic: "Anthropic",
+    Arcee: "Arcee",
     AtlasCloud: "AtlasCloud",
-    Atoma: "Atoma",
     Avian: "Avian",
     Azure: "Azure",
     BaseTen: "BaseTen",
+    BlackForestLabs: "Black Forest Labs",
     Cerebras: "Cerebras",
     Chutes: "Chutes",
     Cirrascale: "Cirrascale",
     Clarifai: "Clarifai",
     Cloudflare: "Cloudflare",
     Cohere: "Cohere",
-    CrofAI: "CrofAI",
     Crusoe: "Crusoe",
     DeepInfra: "DeepInfra",
     DeepSeek: "DeepSeek",
-    Enfer: "Enfer",
     Featherless: "Featherless",
     Fireworks: "Fireworks",
     Friendli: "Friendli",
@@ -39,11 +38,8 @@ export const GetParametersProvider = {
     InferenceNet: "InferenceNet",
     Infermatic: "Infermatic",
     Inflection: "Inflection",
-    Kluster: "Kluster",
-    Lambda: "Lambda",
     Liquid: "Liquid",
     Mancer2: "Mancer 2",
-    Meta: "Meta",
     Minimax: "Minimax",
     ModelRun: "ModelRun",
     Mistral: "Mistral",
@@ -53,7 +49,6 @@ export const GetParametersProvider = {
     NCompass: "NCompass",
     Nebius: "Nebius",
     NextBit: "NextBit",
-    Nineteen: "Nineteen",
     Novita: "Novita",
     Nvidia: "Nvidia",
     OpenAI: "OpenAI",
@@ -68,7 +63,6 @@ export const GetParametersProvider = {
     Switchpoint: "Switchpoint",
     Targon: "Targon",
     Together: "Together",
-    Ubicloud: "Ubicloud",
     Venice: "Venice",
     WandB: "WandB",
     XAI: "xAI",

package/esm/models/operations/list.js

@@ -36,7 +36,7 @@ export const ListData$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/updatekeys.js

@@ -63,7 +63,7 @@ export const UpdateKeysData$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",