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

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 {
@@ -31,9 +36,10 @@ export type ResponsesOutputItemReasoningType = ClosedEnum<
 export const ResponsesOutputItemReasoningFormat = {
   Unknown: "unknown",
   OpenaiResponsesV1: "openai-responses-v1",
+  XaiResponsesV1: "xai-responses-v1",
   AnthropicClaudeV1: "anthropic-claude-v1",
 } as const;
-export type ResponsesOutputItemReasoningFormat = ClosedEnum<
+export type ResponsesOutputItemReasoningFormat = OpenEnum<
   typeof ResponsesOutputItemReasoningFormat
 >;
 
@@ -72,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

package/src/models/responsesstreamchunkunion.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 {
@@ -333,7 +338,7 @@ export const ItemStatusEnum4 = {
   Completed: "completed",
   Searching: "searching",
 } as const;
-export type ItemStatusEnum4 = ClosedEnum<typeof ItemStatusEnum4>;
+export type ItemStatusEnum4 = OpenEnum<typeof ItemStatusEnum4>;
 
 export type ItemWebSearchCall2 = {
   type: ItemTypeWebSearchCall2;
@@ -354,7 +359,7 @@ export const ItemStatusEnum3 = {
   Generating: "generating",
   Failed: "failed",
 } as const;
-export type ItemStatusEnum3 = ClosedEnum<typeof ItemStatusEnum3>;
+export type ItemStatusEnum3 = OpenEnum<typeof ItemStatusEnum3>;
 
 export type ItemImageGenerationCall = {
   type: ItemTypeImageGenerationCall;
@@ -456,7 +461,7 @@ export const ItemStatusEnum2 = {
   InProgress: "in_progress",
   Failed: "failed",
 } as const;
-export type ItemStatusEnum2 = ClosedEnum<typeof ItemStatusEnum2>;
+export type ItemStatusEnum2 = OpenEnum<typeof ItemStatusEnum2>;
 
 export type ItemFileSearchCall = {
   type: ItemTypeFileSearchCall;
@@ -476,7 +481,7 @@ export const ItemStatusEnum1 = {
   InProgress: "in_progress",
   Failed: "failed",
 } as const;
-export type ItemStatusEnum1 = ClosedEnum<typeof ItemStatusEnum1>;
+export type ItemStatusEnum1 = OpenEnum<typeof ItemStatusEnum1>;
 
 export type ItemWebSearchCall1 = {
   type: ItemTypeWebSearchCall1;
@@ -595,7 +600,7 @@ export const ResponsesStreamChunkType = {
   ResponseCompleted: "response.completed",
   ResponseIncomplete: "response.incomplete",
 } as const;
-export type ResponsesStreamChunkType = ClosedEnum<
+export type ResponsesStreamChunkType = OpenEnum<
   typeof ResponsesStreamChunkType
 >;
 
@@ -603,7 +608,7 @@ export const ResponsesStreamChunkReason = {
   MaxOutputTokens: "max_output_tokens",
   ContentFilter: "content_filter",
 } as const;
-export type ResponsesStreamChunkReason = ClosedEnum<
+export type ResponsesStreamChunkReason = OpenEnum<
   typeof ResponsesStreamChunkReason
 >;
 
@@ -3015,14 +3020,25 @@ export namespace ItemTypeWebSearchCall2$ {
 }
 
 /** @internal */
-export const ItemStatusEnum4$inboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum4
-> = z.nativeEnum(ItemStatusEnum4);
+export const ItemStatusEnum4$inboundSchema: z.ZodType<
+  ItemStatusEnum4,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ItemStatusEnum4),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ItemStatusEnum4$outboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum4
-> = ItemStatusEnum4$inboundSchema;
+export const ItemStatusEnum4$outboundSchema: z.ZodType<
+  ItemStatusEnum4,
+  z.ZodTypeDef,
+  ItemStatusEnum4
+> = z.union([
+  z.nativeEnum(ItemStatusEnum4),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -3117,14 +3133,25 @@ export namespace ItemTypeImageGenerationCall$ {
 }
 
 /** @internal */
-export const ItemStatusEnum3$inboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum3
-> = z.nativeEnum(ItemStatusEnum3);
+export const ItemStatusEnum3$inboundSchema: z.ZodType<
+  ItemStatusEnum3,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ItemStatusEnum3),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ItemStatusEnum3$outboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum3
-> = ItemStatusEnum3$inboundSchema;
+export const ItemStatusEnum3$outboundSchema: z.ZodType<
+  ItemStatusEnum3,
+  z.ZodTypeDef,
+  ItemStatusEnum3
+> = z.union([
+  z.nativeEnum(ItemStatusEnum3),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -3837,14 +3864,25 @@ export namespace ItemTypeFileSearchCall$ {
 }
 
 /** @internal */
-export const ItemStatusEnum2$inboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum2
-> = z.nativeEnum(ItemStatusEnum2);
+export const ItemStatusEnum2$inboundSchema: z.ZodType<
+  ItemStatusEnum2,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ItemStatusEnum2),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ItemStatusEnum2$outboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum2
-> = ItemStatusEnum2$inboundSchema;
+export const ItemStatusEnum2$outboundSchema: z.ZodType<
+  ItemStatusEnum2,
+  z.ZodTypeDef,
+  ItemStatusEnum2
+> = z.union([
+  z.nativeEnum(ItemStatusEnum2),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -3942,14 +3980,25 @@ export namespace ItemTypeWebSearchCall1$ {
 }
 
 /** @internal */
-export const ItemStatusEnum1$inboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum1
-> = z.nativeEnum(ItemStatusEnum1);
+export const ItemStatusEnum1$inboundSchema: z.ZodType<
+  ItemStatusEnum1,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ItemStatusEnum1),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ItemStatusEnum1$outboundSchema: z.ZodNativeEnum<
-  typeof ItemStatusEnum1
-> = ItemStatusEnum1$inboundSchema;
+export const ItemStatusEnum1$outboundSchema: z.ZodType<
+  ItemStatusEnum1,
+  z.ZodTypeDef,
+  ItemStatusEnum1
+> = z.union([
+  z.nativeEnum(ItemStatusEnum1),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -4818,14 +4867,25 @@ export function responsesStreamChunkResponseCreatedFromJSON(
 }
 
 /** @internal */
-export const ResponsesStreamChunkType$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesStreamChunkType
-> = z.nativeEnum(ResponsesStreamChunkType);
+export const ResponsesStreamChunkType$inboundSchema: z.ZodType<
+  ResponsesStreamChunkType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesStreamChunkType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesStreamChunkType$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesStreamChunkType
-> = ResponsesStreamChunkType$inboundSchema;
+export const ResponsesStreamChunkType$outboundSchema: z.ZodType<
+  ResponsesStreamChunkType,
+  z.ZodTypeDef,
+  ResponsesStreamChunkType
+> = z.union([
+  z.nativeEnum(ResponsesStreamChunkType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -4839,14 +4899,25 @@ export namespace ResponsesStreamChunkType$ {
 }
 
 /** @internal */
-export const ResponsesStreamChunkReason$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesStreamChunkReason
-> = z.nativeEnum(ResponsesStreamChunkReason);
+export const ResponsesStreamChunkReason$inboundSchema: z.ZodType<
+  ResponsesStreamChunkReason,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesStreamChunkReason),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesStreamChunkReason$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesStreamChunkReason
-> = ResponsesStreamChunkReason$inboundSchema;
+export const ResponsesStreamChunkReason$outboundSchema: z.ZodType<
+  ResponsesStreamChunkReason,
+  z.ZodTypeDef,
+  ResponsesStreamChunkReason
+> = z.union([
+  z.nativeEnum(ResponsesStreamChunkReason),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responseswebsearchcalloutput.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 ResponsesWebSearchCallOutputStatus = {
   InProgress: "in_progress",
   Failed: "failed",
 } as const;
-export type ResponsesWebSearchCallOutputStatus = ClosedEnum<
+export type ResponsesWebSearchCallOutputStatus = OpenEnum<
   typeof ResponsesWebSearchCallOutputStatus
 >;
 
@@ -56,14 +61,25 @@ export namespace ResponsesWebSearchCallOutputType$ {
 }
 
 /** @internal */
-export const ResponsesWebSearchCallOutputStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesWebSearchCallOutputStatus
-> = z.nativeEnum(ResponsesWebSearchCallOutputStatus);
+export const ResponsesWebSearchCallOutputStatus$inboundSchema: z.ZodType<
+  ResponsesWebSearchCallOutputStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesWebSearchCallOutputStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesWebSearchCallOutputStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesWebSearchCallOutputStatus
-> = ResponsesWebSearchCallOutputStatus$inboundSchema;
+export const ResponsesWebSearchCallOutputStatus$outboundSchema: z.ZodType<
+  ResponsesWebSearchCallOutputStatus,
+  z.ZodTypeDef,
+  ResponsesWebSearchCallOutputStatus
+> = z.union([
+  z.nativeEnum(ResponsesWebSearchCallOutputStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsetextverbosity.ts

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