@unified-api/typescript-sdk 2.80.2 → 2.80.4

package/src/sdk/models/shared/verificationparameter.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -46,11 +47,7 @@ export const VerificationParameterType$inboundSchema: z.ZodType<
   VerificationParameterType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(VerificationParameterType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(VerificationParameterType);
 
 /** @internal */
 export const VerificationParameter$inboundSchema: z.ZodType<

package/src/sdk/models/shared/verificationrequest.ts

@@ -5,11 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -84,40 +81,26 @@ export const ProfileGender$inboundSchema: z.ZodType<
   ProfileGender,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ProfileGender),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ProfileGender);
 /** @internal */
 export const ProfileGender$outboundSchema: z.ZodType<
-  ProfileGender,
+  string,
   z.ZodTypeDef,
   ProfileGender
-> = z.union([
-  z.nativeEnum(ProfileGender),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ProfileGender);
 
 /** @internal */
 export const ResponseStatus$inboundSchema: z.ZodType<
   ResponseStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ResponseStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ResponseStatus);
 /** @internal */
 export const ResponseStatus$outboundSchema: z.ZodType<
-  ResponseStatus,
+  string,
   z.ZodTypeDef,
   ResponseStatus
-> = z.union([
-  z.nativeEnum(ResponseStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ResponseStatus);
 
 /** @internal */
 export const VerificationRequest$inboundSchema: z.ZodType<

package/src/sdk/models/shared/webhook.ts

@@ -5,11 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -169,70 +166,44 @@ export type Webhook = {
 };
 
 /** @internal */
-export const DbType$inboundSchema: z.ZodType<DbType, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(DbType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const DbType$inboundSchema: z.ZodType<DbType, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(DbType);
 /** @internal */
-export const DbType$outboundSchema: z.ZodType<DbType, z.ZodTypeDef, DbType> = z
-  .union([
-    z.nativeEnum(DbType),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+export const DbType$outboundSchema: z.ZodType<string, z.ZodTypeDef, DbType> =
+  openEnums.outboundSchema(DbType);
 
 /** @internal */
-export const Event$inboundSchema: z.ZodType<Event, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Event),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Event$inboundSchema: z.ZodType<Event, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Event);
 /** @internal */
-export const Event$outboundSchema: z.ZodType<Event, z.ZodTypeDef, Event> = z
-  .union([
-    z.nativeEnum(Event),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+export const Event$outboundSchema: z.ZodType<string, z.ZodTypeDef, Event> =
+  openEnums.outboundSchema(Event);
 
 /** @internal */
 export const ObjectType$inboundSchema: z.ZodType<
   ObjectType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ObjectType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ObjectType);
 /** @internal */
 export const ObjectType$outboundSchema: z.ZodType<
-  ObjectType,
+  string,
   z.ZodTypeDef,
   ObjectType
-> = z.union([
-  z.nativeEnum(ObjectType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ObjectType);
 
 /** @internal */
 export const WebhookType$inboundSchema: z.ZodType<
   WebhookType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(WebhookType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(WebhookType);
 /** @internal */
 export const WebhookType$outboundSchema: z.ZodType<
-  WebhookType,
+  string,
   z.ZodTypeDef,
   WebhookType
-> = z.union([
-  z.nativeEnum(WebhookType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(WebhookType);
 
 /** @internal */
 export const Webhook$inboundSchema: z.ZodType<Webhook, z.ZodTypeDef, unknown> =

package/src/sdk/types/enums.ts

@@ -2,15 +2,64 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import * as z from "zod/v3";
+
 declare const __brand: unique symbol;
 export type Unrecognized<T> = T & { [__brand]: "unrecognized" };
+export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
+  T[keyof T];
+export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
+  | T[keyof T]
+  | Unrecognized<T[keyof T] extends number ? number : string>;
 
-export function catchUnrecognizedEnum<T>(value: T): Unrecognized<T> {
+function unrecognized<T>(value: T): Unrecognized<T> {
+  unrecognizedCount++;
   return value as Unrecognized<T>;
 }
 
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-export type ClosedEnum<T> = T[keyof T];
-export type OpenEnum<T> =
-  | Prettify<T[keyof T]>
-  | Unrecognized<T[keyof T] extends number ? number : string>;
+let unrecognizedCount = 0;
+let refCount = 0;
+export function unrecognizedCounter() {
+  refCount++;
+  const start = unrecognizedCount;
+  return {
+    count: () => {
+      const count = unrecognizedCount - start;
+      if (--refCount === 0) unrecognizedCount = 0;
+      return count;
+    },
+  };
+}
+
+export function inboundSchema<T extends Record<string, string>>(
+  enumObj: T,
+): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+  const options = Object.values(enumObj);
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.string().transform(x => unrecognized(x)),
+  ] as any);
+}
+
+export function inboundSchemaInt<T extends Record<string, number | string>>(
+  enumObj: T,
+): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+  // For numeric enums, Object.values returns both numbers and string keys
+  const options = Object.values(enumObj).filter(v => typeof v === "number");
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.number().int().transform(x => unrecognized(x)),
+  ] as any);
+}
+
+export function outboundSchema<T extends Record<string, string>>(
+  _: T,
+): z.ZodType<string, z.ZodTypeDef, OpenEnum<T>> {
+  return z.string() as any;
+}
+
+export function outboundSchemaInt<T extends Record<string, number | string>>(
+  _: T,
+): z.ZodType<number, z.ZodTypeDef, OpenEnum<T>> {
+  return z.number().int() as any;
+}

package/src/sdk/types/index.ts

@@ -3,7 +3,6 @@
  */
 
 export { blobLikeSchema, isBlobLike } from "./blobs.js";
-export { catchUnrecognizedEnum } from "./enums.js";
 export type { ClosedEnum, OpenEnum, Unrecognized } from "./enums.js";
 export type { Result } from "./fp.js";
 export type { PageIterator, Paginator } from "./operations.js";