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

package/src/models/responseimagegenerationcallstatus.ts

@@ -3,7 +3,11 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseImageGenerationCallStatus = {
   InProgress: "in_progress",
@@ -11,19 +15,30 @@ export const ResponseImageGenerationCallStatus = {
   Generating: "generating",
   Failed: "failed",
 } as const;
-export type ResponseImageGenerationCallStatus = ClosedEnum<
+export type ResponseImageGenerationCallStatus = OpenEnum<
   typeof ResponseImageGenerationCallStatus
 >;
 
 /** @internal */
-export const ResponseImageGenerationCallStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseImageGenerationCallStatus
-> = z.nativeEnum(ResponseImageGenerationCallStatus);
+export const ResponseImageGenerationCallStatus$inboundSchema: z.ZodType<
+  ResponseImageGenerationCallStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseImageGenerationCallStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseImageGenerationCallStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseImageGenerationCallStatus
-> = ResponseImageGenerationCallStatus$inboundSchema;
+export const ResponseImageGenerationCallStatus$outboundSchema: z.ZodType<
+  ResponseImageGenerationCallStatus,
+  z.ZodTypeDef,
+  ResponseImageGenerationCallStatus
+> = z.union([
+  z.nativeEnum(ResponseImageGenerationCallStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responseincludable.ts

@@ -3,7 +3,11 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 /**
  * Includable fields for response
@@ -18,17 +22,28 @@ export const ResponseIncludable = {
 /**
  * Includable fields for response
  */
-export type ResponseIncludable = ClosedEnum<typeof ResponseIncludable>;
+export type ResponseIncludable = OpenEnum<typeof ResponseIncludable>;
 
 /** @internal */
-export const ResponseIncludable$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseIncludable
-> = z.nativeEnum(ResponseIncludable);
+export const ResponseIncludable$inboundSchema: z.ZodType<
+  ResponseIncludable,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseIncludable),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseIncludable$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseIncludable
-> = ResponseIncludable$inboundSchema;
+export const ResponseIncludable$outboundSchema: z.ZodType<
+  ResponseIncludable,
+  z.ZodTypeDef,
+  ResponseIncludable
+> = z.union([
+  z.nativeEnum(ResponseIncludable),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responseinputimagedetail.ts

@@ -3,26 +3,41 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseInputImageDetail = {
   Auto: "auto",
   High: "high",
   Low: "low",
 } as const;
-export type ResponseInputImageDetail = ClosedEnum<
+export type ResponseInputImageDetail = OpenEnum<
   typeof ResponseInputImageDetail
 >;
 
 /** @internal */
-export const ResponseInputImageDetail$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseInputImageDetail
-> = z.nativeEnum(ResponseInputImageDetail);
+export const ResponseInputImageDetail$inboundSchema: z.ZodType<
+  ResponseInputImageDetail,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseInputImageDetail),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseInputImageDetail$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseInputImageDetail
-> = ResponseInputImageDetail$inboundSchema;
+export const ResponseInputImageDetail$outboundSchema: z.ZodType<
+  ResponseInputImageDetail,
+  z.ZodTypeDef,
+  ResponseInputImageDetail
+> = z.union([
+  z.nativeEnum(ResponseInputImageDetail),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsereasoningconfig.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 {
@@ -20,7 +24,7 @@ export const ResponseReasoningConfigEffort = {
   Low: "low",
   Minimal: "minimal",
 } as const;
-export type ResponseReasoningConfigEffort = ClosedEnum<
+export type ResponseReasoningConfigEffort = OpenEnum<
   typeof ResponseReasoningConfigEffort
 >;
 
@@ -35,14 +39,25 @@ export type ResponseReasoningConfig = {
 };
 
 /** @internal */
-export const ResponseReasoningConfigEffort$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningConfigEffort
-> = z.nativeEnum(ResponseReasoningConfigEffort);
+export const ResponseReasoningConfigEffort$inboundSchema: z.ZodType<
+  ResponseReasoningConfigEffort,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseReasoningConfigEffort),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseReasoningConfigEffort$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningConfigEffort
-> = ResponseReasoningConfigEffort$inboundSchema;
+export const ResponseReasoningConfigEffort$outboundSchema: z.ZodType<
+  ResponseReasoningConfigEffort,
+  z.ZodTypeDef,
+  ResponseReasoningConfigEffort
+> = z.union([
+  z.nativeEnum(ResponseReasoningConfigEffort),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsereasoningsummarymode.ts

@@ -3,26 +3,41 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseReasoningSummaryMode = {
   Auto: "auto",
   Concise: "concise",
   Detailed: "detailed",
 } as const;
-export type ResponseReasoningSummaryMode = ClosedEnum<
+export type ResponseReasoningSummaryMode = OpenEnum<
   typeof ResponseReasoningSummaryMode
 >;
 
 /** @internal */
-export const ResponseReasoningSummaryMode$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningSummaryMode
-> = z.nativeEnum(ResponseReasoningSummaryMode);
+export const ResponseReasoningSummaryMode$inboundSchema: z.ZodType<
+  ResponseReasoningSummaryMode,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseReasoningSummaryMode),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseReasoningSummaryMode$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningSummaryMode
-> = ResponseReasoningSummaryMode$inboundSchema;
+export const ResponseReasoningSummaryMode$outboundSchema: z.ZodType<
+  ResponseReasoningSummaryMode,
+  z.ZodTypeDef,
+  ResponseReasoningSummaryMode
+> = z.union([
+  z.nativeEnum(ResponseReasoningSummaryMode),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsesincompletedetails.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";
 
@@ -12,7 +16,7 @@ export const ResponsesIncompleteDetailsReason = {
   MaxOutputTokens: "max_output_tokens",
   ContentFilter: "content_filter",
 } as const;
-export type ResponsesIncompleteDetailsReason = ClosedEnum<
+export type ResponsesIncompleteDetailsReason = OpenEnum<
   typeof ResponsesIncompleteDetailsReason
 >;
 
@@ -24,14 +28,25 @@ export type ResponsesIncompleteDetails = {
 };
 
 /** @internal */
-export const ResponsesIncompleteDetailsReason$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesIncompleteDetailsReason
-> = z.nativeEnum(ResponsesIncompleteDetailsReason);
+export const ResponsesIncompleteDetailsReason$inboundSchema: z.ZodType<
+  ResponsesIncompleteDetailsReason,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesIncompleteDetailsReason),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesIncompleteDetailsReason$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesIncompleteDetailsReason
-> = ResponsesIncompleteDetailsReason$inboundSchema;
+export const ResponsesIncompleteDetailsReason$outboundSchema: z.ZodType<
+  ResponsesIncompleteDetailsReason,
+  z.ZodTypeDef,
+  ResponsesIncompleteDetailsReason
+> = z.union([
+  z.nativeEnum(ResponsesIncompleteDetailsReason),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsesnonstreamingresponse.ts

@@ -5,7 +5,12 @@
 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,
+  ClosedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
@@ -76,7 +81,7 @@ export const ResponsesNonStreamingResponseStatus = {
   Cancelled: "cancelled",
   Queued: "queued",
 } as const;
-export type ResponsesNonStreamingResponseStatus = ClosedEnum<
+export type ResponsesNonStreamingResponseStatus = OpenEnum<
   typeof ResponsesNonStreamingResponseStatus
 >;
 
@@ -85,7 +90,7 @@ export const ResponsesNonStreamingResponseCode = {
   RateLimitExceeded: "rate_limit_exceeded",
   InvalidPrompt: "invalid_prompt",
 } as const;
-export type ResponsesNonStreamingResponseCode = ClosedEnum<
+export type ResponsesNonStreamingResponseCode = OpenEnum<
   typeof ResponsesNonStreamingResponseCode
 >;
 
@@ -103,13 +108,13 @@ export const ServiceTier = {
   Priority: "priority",
   Scale: "scale",
 } as const;
-export type ServiceTier = ClosedEnum<typeof ServiceTier>;
+export type ServiceTier = OpenEnum<typeof ServiceTier>;
 
 export const Truncation = {
   Auto: "auto",
   Disabled: "disabled",
 } as const;
-export type Truncation = ClosedEnum<typeof Truncation>;
+export type Truncation = OpenEnum<typeof Truncation>;
 
 /**
  * Non-streaming response from Responses API
@@ -189,14 +194,25 @@ export namespace ObjectT$ {
 }
 
 /** @internal */
-export const ResponsesNonStreamingResponseStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesNonStreamingResponseStatus
-> = z.nativeEnum(ResponsesNonStreamingResponseStatus);
+export const ResponsesNonStreamingResponseStatus$inboundSchema: z.ZodType<
+  ResponsesNonStreamingResponseStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesNonStreamingResponseStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesNonStreamingResponseStatus$outboundSchema:
-  z.ZodNativeEnum<typeof ResponsesNonStreamingResponseStatus> =
-    ResponsesNonStreamingResponseStatus$inboundSchema;
+export const ResponsesNonStreamingResponseStatus$outboundSchema: z.ZodType<
+  ResponsesNonStreamingResponseStatus,
+  z.ZodTypeDef,
+  ResponsesNonStreamingResponseStatus
+> = z.union([
+  z.nativeEnum(ResponsesNonStreamingResponseStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -212,14 +228,25 @@ export namespace ResponsesNonStreamingResponseStatus$ {
 }
 
 /** @internal */
-export const ResponsesNonStreamingResponseCode$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesNonStreamingResponseCode
-> = z.nativeEnum(ResponsesNonStreamingResponseCode);
+export const ResponsesNonStreamingResponseCode$inboundSchema: z.ZodType<
+  ResponsesNonStreamingResponseCode,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesNonStreamingResponseCode),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesNonStreamingResponseCode$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesNonStreamingResponseCode
-> = ResponsesNonStreamingResponseCode$inboundSchema;
+export const ResponsesNonStreamingResponseCode$outboundSchema: z.ZodType<
+  ResponsesNonStreamingResponseCode,
+  z.ZodTypeDef,
+  ResponsesNonStreamingResponseCode
+> = z.union([
+  z.nativeEnum(ResponsesNonStreamingResponseCode),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -342,12 +369,25 @@ export function instructionsFromJSON(
 }
 
 /** @internal */
-export const ServiceTier$inboundSchema: z.ZodNativeEnum<typeof ServiceTier> = z
-  .nativeEnum(ServiceTier);
+export const ServiceTier$inboundSchema: z.ZodType<
+  ServiceTier,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ServiceTier),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ServiceTier$outboundSchema: z.ZodNativeEnum<typeof ServiceTier> =
-  ServiceTier$inboundSchema;
+export const ServiceTier$outboundSchema: z.ZodType<
+  ServiceTier,
+  z.ZodTypeDef,
+  ServiceTier
+> = z.union([
+  z.nativeEnum(ServiceTier),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -361,12 +401,25 @@ export namespace ServiceTier$ {
 }
 
 /** @internal */
-export const Truncation$inboundSchema: z.ZodNativeEnum<typeof Truncation> = z
-  .nativeEnum(Truncation);
+export const Truncation$inboundSchema: z.ZodType<
+  Truncation,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(Truncation),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Truncation$outboundSchema: z.ZodNativeEnum<typeof Truncation> =
-  Truncation$inboundSchema;
+export const Truncation$outboundSchema: z.ZodType<
+  Truncation,
+  z.ZodTypeDef,
+  Truncation
+> = z.union([
+  z.nativeEnum(Truncation),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsesoutputitemfilesearchcall.ts

@@ -4,7 +4,12 @@
 
 import * as z from "zod";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  ClosedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -21,7 +26,7 @@ export const ResponsesOutputItemFileSearchCallStatus = {
   InProgress: "in_progress",
   Failed: "failed",
 } as const;
-export type ResponsesOutputItemFileSearchCallStatus = ClosedEnum<
+export type ResponsesOutputItemFileSearchCallStatus = OpenEnum<
   typeof ResponsesOutputItemFileSearchCallStatus
 >;
 
@@ -60,14 +65,25 @@ export namespace ResponsesOutputItemFileSearchCallType$ {
 }
 
 /** @internal */
-export const ResponsesOutputItemFileSearchCallStatus$inboundSchema:
-  z.ZodNativeEnum<typeof ResponsesOutputItemFileSearchCallStatus> = z
-    .nativeEnum(ResponsesOutputItemFileSearchCallStatus);
+export const ResponsesOutputItemFileSearchCallStatus$inboundSchema: z.ZodType<
+  ResponsesOutputItemFileSearchCallStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesOutputItemFileSearchCallStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesOutputItemFileSearchCallStatus$outboundSchema:
-  z.ZodNativeEnum<typeof ResponsesOutputItemFileSearchCallStatus> =
-    ResponsesOutputItemFileSearchCallStatus$inboundSchema;
+export const ResponsesOutputItemFileSearchCallStatus$outboundSchema: z.ZodType<
+  ResponsesOutputItemFileSearchCallStatus,
+  z.ZodTypeDef,
+  ResponsesOutputItemFileSearchCallStatus
+> = z.union([
+  z.nativeEnum(ResponsesOutputItemFileSearchCallStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsesoutputitemreasoning.ts

@@ -5,7 +5,12 @@
 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,
+  ClosedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
@@ -34,7 +39,7 @@ export const ResponsesOutputItemReasoningFormat = {
   XaiResponsesV1: "xai-responses-v1",
   AnthropicClaudeV1: "anthropic-claude-v1",
 } as const;
-export type ResponsesOutputItemReasoningFormat = ClosedEnum<
+export type ResponsesOutputItemReasoningFormat = OpenEnum<
   typeof ResponsesOutputItemReasoningFormat
 >;
 
@@ -73,14 +78,25 @@ export namespace ResponsesOutputItemReasoningType$ {
 }
 
 /** @internal */
-export const ResponsesOutputItemReasoningFormat$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemReasoningFormat
-> = z.nativeEnum(ResponsesOutputItemReasoningFormat);
+export const ResponsesOutputItemReasoningFormat$inboundSchema: z.ZodType<
+  ResponsesOutputItemReasoningFormat,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesOutputItemReasoningFormat),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesOutputItemReasoningFormat$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesOutputItemReasoningFormat
-> = ResponsesOutputItemReasoningFormat$inboundSchema;
+export const ResponsesOutputItemReasoningFormat$outboundSchema: z.ZodType<
+  ResponsesOutputItemReasoningFormat,
+  z.ZodTypeDef,
+  ResponsesOutputItemReasoningFormat
+> = z.union([
+  z.nativeEnum(ResponsesOutputItemReasoningFormat),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal