@openrouter/sdk 0.0.0-beta.38 → 0.0.0-beta.39

package/src/models/endpointslist.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -130,7 +134,7 @@ export const ProviderName = {
   ZAi: "Z.AI",
   FakeProvider: "FakeProvider",
 } as const;
-export type ProviderName = ClosedEnum<typeof ProviderName>;
+export type ProviderName = OpenEnum<typeof ProviderName>;
 
 export const Quantization = {
   Int4: "int4",
@@ -143,7 +147,7 @@ export const Quantization = {
   Fp32: "fp32",
   Unknown: "unknown",
 } as const;
-export type Quantization = ClosedEnum<typeof Quantization>;
+export type Quantization = OpenEnum<typeof Quantization>;
 
 export const EndpointsListSupportedParameter = {
   Temperature: "temperature",
@@ -170,7 +174,7 @@ export const EndpointsListSupportedParameter = {
   WebSearchOptions: "web_search_options",
   Verbosity: "verbosity",
 } as const;
-export type EndpointsListSupportedParameter = ClosedEnum<
+export type EndpointsListSupportedParameter = OpenEnum<
   typeof EndpointsListSupportedParameter
 >;
 
@@ -182,7 +186,7 @@ export const EndpointsListStatus = {
   Minus5: -5,
   Minus10: -10,
 } as const;
-export type EndpointsListStatus = ClosedEnum<typeof EndpointsListStatus>;
+export type EndpointsListStatus = OpenEnum<typeof EndpointsListStatus>;
 
 export type EndpointsList = {
   name: string;
@@ -842,12 +846,25 @@ export function endpointsListPricingFromJSON(
 }
 
 /** @internal */
-export const ProviderName$inboundSchema: z.ZodNativeEnum<typeof ProviderName> =
-  z.nativeEnum(ProviderName);
+export const ProviderName$inboundSchema: z.ZodType<
+  ProviderName,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ProviderName),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ProviderName$outboundSchema: z.ZodNativeEnum<typeof ProviderName> =
-  ProviderName$inboundSchema;
+export const ProviderName$outboundSchema: z.ZodType<
+  ProviderName,
+  z.ZodTypeDef,
+  ProviderName
+> = z.union([
+  z.nativeEnum(ProviderName),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -861,12 +878,25 @@ export namespace ProviderName$ {
 }
 
 /** @internal */
-export const Quantization$inboundSchema: z.ZodNativeEnum<typeof Quantization> =
-  z.nativeEnum(Quantization);
+export const Quantization$inboundSchema: z.ZodType<
+  Quantization,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(Quantization),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Quantization$outboundSchema: z.ZodNativeEnum<typeof Quantization> =
-  Quantization$inboundSchema;
+export const Quantization$outboundSchema: z.ZodType<
+  Quantization,
+  z.ZodTypeDef,
+  Quantization
+> = z.union([
+  z.nativeEnum(Quantization),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -880,14 +910,25 @@ export namespace Quantization$ {
 }
 
 /** @internal */
-export const EndpointsListSupportedParameter$inboundSchema: z.ZodNativeEnum<
-  typeof EndpointsListSupportedParameter
-> = z.nativeEnum(EndpointsListSupportedParameter);
+export const EndpointsListSupportedParameter$inboundSchema: z.ZodType<
+  EndpointsListSupportedParameter,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(EndpointsListSupportedParameter),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const EndpointsListSupportedParameter$outboundSchema: z.ZodNativeEnum<
-  typeof EndpointsListSupportedParameter
-> = EndpointsListSupportedParameter$inboundSchema;
+export const EndpointsListSupportedParameter$outboundSchema: z.ZodType<
+  EndpointsListSupportedParameter,
+  z.ZodTypeDef,
+  EndpointsListSupportedParameter
+> = z.union([
+  z.nativeEnum(EndpointsListSupportedParameter),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -901,14 +942,25 @@ export namespace EndpointsListSupportedParameter$ {
 }
 
 /** @internal */
-export const EndpointsListStatus$inboundSchema: z.ZodNativeEnum<
-  typeof EndpointsListStatus
-> = z.nativeEnum(EndpointsListStatus);
+export const EndpointsListStatus$inboundSchema: z.ZodType<
+  EndpointsListStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(EndpointsListStatus),
+    z.number().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const EndpointsListStatus$outboundSchema: z.ZodNativeEnum<
-  typeof EndpointsListStatus
-> = EndpointsListStatus$inboundSchema;
+export const EndpointsListStatus$outboundSchema: z.ZodType<
+  EndpointsListStatus,
+  z.ZodTypeDef,
+  EndpointsListStatus
+> = z.union([
+  z.nativeEnum(EndpointsListStatus),
+  z.number().and(z.custom<Unrecognized<number>>()),
+]);
 
 /**
  * @internal

package/src/models/errorresponse.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -80,7 +84,7 @@ export const ErrorResponseCode = {
   FiveHundredAndTwentyNine: 529,
   FiveHundredAndThirty: 530,
 } as const;
-export type ErrorResponseCode = ClosedEnum<typeof ErrorResponseCode>;
+export type ErrorResponseCode = OpenEnum<typeof ErrorResponseCode>;
 
 export type ErrorResponseError = {
   code: ErrorResponseCode;
@@ -89,14 +93,25 @@ export type ErrorResponseError = {
 };
 
 /** @internal */
-export const ErrorResponseCode$inboundSchema: z.ZodNativeEnum<
-  typeof ErrorResponseCode
-> = z.nativeEnum(ErrorResponseCode);
+export const ErrorResponseCode$inboundSchema: z.ZodType<
+  ErrorResponseCode,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ErrorResponseCode),
+    z.number().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ErrorResponseCode$outboundSchema: z.ZodNativeEnum<
-  typeof ErrorResponseCode
-> = ErrorResponseCode$inboundSchema;
+export const ErrorResponseCode$outboundSchema: z.ZodType<
+  ErrorResponseCode,
+  z.ZodTypeDef,
+  ErrorResponseCode
+> = z.union([
+  z.nativeEnum(ErrorResponseCode),
+  z.number().and(z.custom<Unrecognized<number>>()),
+]);
 
 /**
  * @internal

package/src/models/modelslist.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -76,7 +80,7 @@ export const Tokenizer = {
 /**
  * Tokenizer type used by the model
  */
-export type Tokenizer = ClosedEnum<typeof Tokenizer>;
+export type Tokenizer = OpenEnum<typeof Tokenizer>;
 
 /**
  * Instruction format type
@@ -108,7 +112,7 @@ export const InstructType = {
 /**
  * Instruction format type
  */
-export type InstructType = ClosedEnum<typeof InstructType>;
+export type InstructType = OpenEnum<typeof InstructType>;
 
 export const InputModality = {
   Text: "text",
@@ -116,14 +120,14 @@ export const InputModality = {
   File: "file",
   Audio: "audio",
 } as const;
-export type InputModality = ClosedEnum<typeof InputModality>;
+export type InputModality = OpenEnum<typeof InputModality>;
 
 export const OutputModality = {
   Text: "text",
   Image: "image",
   Embeddings: "embeddings",
 } as const;
-export type OutputModality = ClosedEnum<typeof OutputModality>;
+export type OutputModality = OpenEnum<typeof OutputModality>;
 
 /**
  * Model architecture information
@@ -208,7 +212,7 @@ export const ModelsListSupportedParameter = {
   WebSearchOptions: "web_search_options",
   Verbosity: "verbosity",
 } as const;
-export type ModelsListSupportedParameter = ClosedEnum<
+export type ModelsListSupportedParameter = OpenEnum<
   typeof ModelsListSupportedParameter
 >;
 
@@ -908,12 +912,25 @@ export function modelsListPricingFromJSON(
 }
 
 /** @internal */
-export const Tokenizer$inboundSchema: z.ZodNativeEnum<typeof Tokenizer> = z
-  .nativeEnum(Tokenizer);
+export const Tokenizer$inboundSchema: z.ZodType<
+  Tokenizer,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(Tokenizer),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Tokenizer$outboundSchema: z.ZodNativeEnum<typeof Tokenizer> =
-  Tokenizer$inboundSchema;
+export const Tokenizer$outboundSchema: z.ZodType<
+  Tokenizer,
+  z.ZodTypeDef,
+  Tokenizer
+> = z.union([
+  z.nativeEnum(Tokenizer),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -927,12 +944,25 @@ export namespace Tokenizer$ {
 }
 
 /** @internal */
-export const InstructType$inboundSchema: z.ZodNativeEnum<typeof InstructType> =
-  z.nativeEnum(InstructType);
+export const InstructType$inboundSchema: z.ZodType<
+  InstructType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(InstructType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const InstructType$outboundSchema: z.ZodNativeEnum<typeof InstructType> =
-  InstructType$inboundSchema;
+export const InstructType$outboundSchema: z.ZodType<
+  InstructType,
+  z.ZodTypeDef,
+  InstructType
+> = z.union([
+  z.nativeEnum(InstructType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -946,14 +976,25 @@ export namespace InstructType$ {
 }
 
 /** @internal */
-export const InputModality$inboundSchema: z.ZodNativeEnum<
-  typeof InputModality
-> = z.nativeEnum(InputModality);
+export const InputModality$inboundSchema: z.ZodType<
+  InputModality,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(InputModality),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const InputModality$outboundSchema: z.ZodNativeEnum<
-  typeof InputModality
-> = InputModality$inboundSchema;
+export const InputModality$outboundSchema: z.ZodType<
+  InputModality,
+  z.ZodTypeDef,
+  InputModality
+> = z.union([
+  z.nativeEnum(InputModality),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -967,14 +1008,25 @@ export namespace InputModality$ {
 }
 
 /** @internal */
-export const OutputModality$inboundSchema: z.ZodNativeEnum<
-  typeof OutputModality
-> = z.nativeEnum(OutputModality);
+export const OutputModality$inboundSchema: z.ZodType<
+  OutputModality,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(OutputModality),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const OutputModality$outboundSchema: z.ZodNativeEnum<
-  typeof OutputModality
-> = OutputModality$inboundSchema;
+export const OutputModality$outboundSchema: z.ZodType<
+  OutputModality,
+  z.ZodTypeDef,
+  OutputModality
+> = z.union([
+  z.nativeEnum(OutputModality),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -1197,14 +1249,25 @@ export function perRequestLimitsFromJSON(
 }
 
 /** @internal */
-export const ModelsListSupportedParameter$inboundSchema: z.ZodNativeEnum<
-  typeof ModelsListSupportedParameter
-> = z.nativeEnum(ModelsListSupportedParameter);
+export const ModelsListSupportedParameter$inboundSchema: z.ZodType<
+  ModelsListSupportedParameter,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ModelsListSupportedParameter),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ModelsListSupportedParameter$outboundSchema: z.ZodNativeEnum<
-  typeof ModelsListSupportedParameter
-> = ModelsListSupportedParameter$inboundSchema;
+export const ModelsListSupportedParameter$outboundSchema: z.ZodType<
+  ModelsListSupportedParameter,
+  z.ZodTypeDef,
+  ModelsListSupportedParameter
+> = z.union([
+  z.nativeEnum(ModelsListSupportedParameter),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/operations/addcoinbasecharge.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -18,7 +22,7 @@ export const ChainId = {
   OneHundredAndThirtySeven: 137,
   EightThousandFourHundredAndFiftyThree: 8453,
 } as const;
-export type ChainId = ClosedEnum<typeof ChainId>;
+export type ChainId = OpenEnum<typeof ChainId>;
 
 export type AddCoinbaseChargeRequest = {
   amount: number;
@@ -123,12 +127,19 @@ export function addCoinbaseChargeSecurityFromJSON(
 }
 
 /** @internal */
-export const ChainId$inboundSchema: z.ZodNativeEnum<typeof ChainId> = z
-  .nativeEnum(ChainId);
+export const ChainId$inboundSchema: z.ZodType<ChainId, z.ZodTypeDef, unknown> =
+  z
+    .union([
+      z.nativeEnum(ChainId),
+      z.number().transform(catchUnrecognizedEnum),
+    ]);
 
 /** @internal */
-export const ChainId$outboundSchema: z.ZodNativeEnum<typeof ChainId> =
-  ChainId$inboundSchema;
+export const ChainId$outboundSchema: z.ZodType<ChainId, z.ZodTypeDef, ChainId> =
+  z.union([
+    z.nativeEnum(ChainId),
+    z.number().and(z.custom<Unrecognized<number>>()),
+  ]);
 
 /**
  * @internal

package/src/models/operations/create.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
@@ -21,7 +25,7 @@ export const CreateLimitReset = {
 /**
  * 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.
  */
-export type CreateLimitReset = ClosedEnum<typeof CreateLimitReset>;
+export type CreateLimitReset = OpenEnum<typeof CreateLimitReset>;
 
 export type CreateRequest = {
   /**
@@ -57,14 +61,25 @@ export type CreateResponse = {
 };
 
 /** @internal */
-export const CreateLimitReset$inboundSchema: z.ZodNativeEnum<
-  typeof CreateLimitReset
-> = z.nativeEnum(CreateLimitReset);
+export const CreateLimitReset$inboundSchema: z.ZodType<
+  CreateLimitReset,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(CreateLimitReset),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const CreateLimitReset$outboundSchema: z.ZodNativeEnum<
-  typeof CreateLimitReset
-> = CreateLimitReset$inboundSchema;
+export const CreateLimitReset$outboundSchema: z.ZodType<
+  CreateLimitReset,
+  z.ZodTypeDef,
+  CreateLimitReset
+> = z.union([
+  z.nativeEnum(CreateLimitReset),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/operations/createauthorizationcode.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -19,7 +23,7 @@ export const CreateAuthorizationCodeCodeChallengeMethod = {
 /**
  * The method used to generate the code challenge
  */
-export type CreateAuthorizationCodeCodeChallengeMethod = ClosedEnum<
+export type CreateAuthorizationCodeCodeChallengeMethod = OpenEnum<
   typeof CreateAuthorizationCodeCodeChallengeMethod
 >;
 
@@ -72,13 +76,23 @@ export type CreateAuthorizationCodeResponse = {
 
 /** @internal */
 export const CreateAuthorizationCodeCodeChallengeMethod$inboundSchema:
-  z.ZodNativeEnum<typeof CreateAuthorizationCodeCodeChallengeMethod> = z
-    .nativeEnum(CreateAuthorizationCodeCodeChallengeMethod);
+  z.ZodType<CreateAuthorizationCodeCodeChallengeMethod, z.ZodTypeDef, unknown> =
+    z
+      .union([
+        z.nativeEnum(CreateAuthorizationCodeCodeChallengeMethod),
+        z.string().transform(catchUnrecognizedEnum),
+      ]);
 
 /** @internal */
 export const CreateAuthorizationCodeCodeChallengeMethod$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAuthorizationCodeCodeChallengeMethod> =
-    CreateAuthorizationCodeCodeChallengeMethod$inboundSchema;
+  z.ZodType<
+    CreateAuthorizationCodeCodeChallengeMethod,
+    z.ZodTypeDef,
+    CreateAuthorizationCodeCodeChallengeMethod
+  > = z.union([
+    z.nativeEnum(CreateAuthorizationCodeCodeChallengeMethod),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
 
 /**
  * @internal

package/src/models/operations/exchangeauthorizationcode.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -19,7 +23,7 @@ export const ExchangeAuthorizationCodeCodeChallengeMethod = {
 /**
  * The method used to generate the code challenge
  */
-export type ExchangeAuthorizationCodeCodeChallengeMethod = ClosedEnum<
+export type ExchangeAuthorizationCodeCodeChallengeMethod = OpenEnum<
   typeof ExchangeAuthorizationCodeCodeChallengeMethod
 >;
 
@@ -56,13 +60,26 @@ export type ExchangeAuthorizationCodeResponse = {
 
 /** @internal */
 export const ExchangeAuthorizationCodeCodeChallengeMethod$inboundSchema:
-  z.ZodNativeEnum<typeof ExchangeAuthorizationCodeCodeChallengeMethod> = z
-    .nativeEnum(ExchangeAuthorizationCodeCodeChallengeMethod);
+  z.ZodType<
+    ExchangeAuthorizationCodeCodeChallengeMethod,
+    z.ZodTypeDef,
+    unknown
+  > = z
+    .union([
+      z.nativeEnum(ExchangeAuthorizationCodeCodeChallengeMethod),
+      z.string().transform(catchUnrecognizedEnum),
+    ]);
 
 /** @internal */
 export const ExchangeAuthorizationCodeCodeChallengeMethod$outboundSchema:
-  z.ZodNativeEnum<typeof ExchangeAuthorizationCodeCodeChallengeMethod> =
-    ExchangeAuthorizationCodeCodeChallengeMethod$inboundSchema;
+  z.ZodType<
+    ExchangeAuthorizationCodeCodeChallengeMethod,
+    z.ZodTypeDef,
+    ExchangeAuthorizationCodeCodeChallengeMethod
+  > = z.union([
+    z.nativeEnum(ExchangeAuthorizationCodeCodeChallengeMethod),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
 
 /**
  * @internal