@gr4vy/sdk 1.6.3 → 1.6.4

package/src/models/components/payoutstatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const PayoutStatus = {
   Declined: "declined",
@@ -18,8 +19,4 @@ export const PayoutStatus$inboundSchema: z.ZodType<
   PayoutStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PayoutStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PayoutStatus);

package/src/models/components/paypalshippingoptionsitem.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { OpenEnum, Unrecognized } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import {
   PaypalShippingOptionsItemAmount,
   PaypalShippingOptionsItemAmount$Outbound,
@@ -45,13 +46,10 @@ export type PaypalShippingOptionsItem = {
 
 /** @internal */
 export const PaypalShippingOptionsItemType$outboundSchema: z.ZodType<
-  PaypalShippingOptionsItemType,
+  string,
   z.ZodTypeDef,
   PaypalShippingOptionsItemType
-> = z.union([
-  z.nativeEnum(PaypalShippingOptionsItemType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(PaypalShippingOptionsItemType);
 
 /** @internal */
 export type PaypalShippingOptionsItem$Outbound = {

package/src/models/components/producttype.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ProductType = {
   Physical: "physical",
@@ -26,17 +23,10 @@ export const ProductType$inboundSchema: z.ZodType<
   ProductType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ProductType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ProductType);
 /** @internal */
 export const ProductType$outboundSchema: z.ZodType<
-  ProductType,
+  string,
   z.ZodTypeDef,
   ProductType
-> = z.union([
-  z.nativeEnum(ProductType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ProductType);

package/src/models/components/redirectpaymentmethodcreate.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { OpenEnum, Unrecognized } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * The method to use, this can be any of the methods that support redirect requests.
@@ -151,13 +152,10 @@ export type RedirectPaymentMethodCreate = {
 
 /** @internal */
 export const RedirectPaymentMethodCreateMethod$outboundSchema: z.ZodType<
-  RedirectPaymentMethodCreateMethod,
+  string,
   z.ZodTypeDef,
   RedirectPaymentMethodCreateMethod
-> = z.union([
-  z.nativeEnum(RedirectPaymentMethodCreateMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(RedirectPaymentMethodCreateMethod);
 
 /** @internal */
 export type RedirectPaymentMethodCreate$Outbound = {

package/src/models/components/refundstatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const RefundStatus = {
   Processing: "processing",
@@ -19,8 +20,4 @@ export const RefundStatus$inboundSchema: z.ZodType<
   RefundStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RefundStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RefundStatus);

package/src/models/components/refundtargettype.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const RefundTargetType = {
   PaymentMethod: "payment-method",
@@ -20,17 +17,10 @@ export const RefundTargetType$inboundSchema: z.ZodType<
   RefundTargetType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RefundTargetType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RefundTargetType);
 /** @internal */
 export const RefundTargetType$outboundSchema: z.ZodType<
-  RefundTargetType,
+  string,
   z.ZodTypeDef,
   RefundTargetType
-> = z.union([
-  z.nativeEnum(RefundTargetType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(RefundTargetType);

package/src/models/components/reportcreatortype.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ReportCreatorType = {
   User: "user",
@@ -16,8 +17,4 @@ export const ReportCreatorType$inboundSchema: z.ZodType<
   ReportCreatorType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ReportCreatorType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ReportCreatorType);

package/src/models/components/reportexecutionstatus.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ReportExecutionStatus = {
   Dispatched: "dispatched",
@@ -23,17 +20,10 @@ export const ReportExecutionStatus$inboundSchema: z.ZodType<
   ReportExecutionStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ReportExecutionStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ReportExecutionStatus);
 /** @internal */
 export const ReportExecutionStatus$outboundSchema: z.ZodType<
-  ReportExecutionStatus,
+  string,
   z.ZodTypeDef,
   ReportExecutionStatus
-> = z.union([
-  z.nativeEnum(ReportExecutionStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ReportExecutionStatus);

package/src/models/components/reportschedule.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ReportSchedule = {
   Daily: "daily",
@@ -22,17 +19,10 @@ export const ReportSchedule$inboundSchema: z.ZodType<
   ReportSchedule,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ReportSchedule),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ReportSchedule);
 /** @internal */
 export const ReportSchedule$outboundSchema: z.ZodType<
-  ReportSchedule,
+  string,
   z.ZodTypeDef,
   ReportSchedule
-> = z.union([
-  z.nativeEnum(ReportSchedule),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ReportSchedule);

package/src/models/components/reportspecmodel.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ReportSpecModel = {
   Transactions: "transactions",
@@ -18,8 +19,4 @@ export const ReportSpecModel$inboundSchema: z.ZodType<
   ReportSpecModel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ReportSpecModel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ReportSpecModel);

package/src/models/components/taxidkind.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const TaxIdKind = {
   AeTrn: "ae.trn",
@@ -70,17 +67,10 @@ export const TaxIdKind$inboundSchema: z.ZodType<
   TaxIdKind,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TaxIdKind),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TaxIdKind);
 /** @internal */
 export const TaxIdKind$outboundSchema: z.ZodType<
-  TaxIdKind,
+  string,
   z.ZodTypeDef,
   TaxIdKind
-> = z.union([
-  z.nativeEnum(TaxIdKind),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TaxIdKind);

package/src/models/components/threedsecuremethod.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ThreeDSecureMethod = {
   Challenge: "challenge",
@@ -16,8 +17,4 @@ export const ThreeDSecureMethod$inboundSchema: z.ZodType<
   ThreeDSecureMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ThreeDSecureMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ThreeDSecureMethod);

package/src/models/components/threedsecurestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const ThreeDSecureStatus = {
   SetupError: "setup_error",
@@ -19,8 +20,4 @@ export const ThreeDSecureStatus$inboundSchema: z.ZodType<
   ThreeDSecureStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ThreeDSecureStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ThreeDSecureStatus);

package/src/models/components/transactioneventoutput.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";
 
@@ -113,11 +114,8 @@ export type TransactionEventOutput = {
 };
 
 /** @internal */
-export const Name$inboundSchema: z.ZodType<Name, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Name),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Name$inboundSchema: z.ZodType<Name, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Name);
 
 /** @internal */
 export const TransactionEventOutput$inboundSchema: z.ZodType<

package/src/models/components/transactionintent.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const TransactionIntent = {
   Authorize: "authorize",
@@ -20,17 +17,10 @@ export const TransactionIntent$inboundSchema: z.ZodType<
   TransactionIntent,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TransactionIntent),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TransactionIntent);
 /** @internal */
 export const TransactionIntent$outboundSchema: z.ZodType<
-  TransactionIntent,
+  string,
   z.ZodTypeDef,
   TransactionIntent
-> = z.union([
-  z.nativeEnum(TransactionIntent),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TransactionIntent);

package/src/models/components/transactionintentoutcome.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const TransactionIntentOutcome = {
   Pending: "pending",
@@ -19,8 +20,4 @@ export const TransactionIntentOutcome$inboundSchema: z.ZodType<
   TransactionIntentOutcome,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TransactionIntentOutcome),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TransactionIntentOutcome);

package/src/models/components/transactionpaymentsource.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 /**
  * The way payment method information made it to this transaction.
@@ -31,17 +28,10 @@ export const TransactionPaymentSource$inboundSchema: z.ZodType<
   TransactionPaymentSource,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TransactionPaymentSource),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TransactionPaymentSource);
 /** @internal */
 export const TransactionPaymentSource$outboundSchema: z.ZodType<
-  TransactionPaymentSource,
+  string,
   z.ZodTypeDef,
   TransactionPaymentSource
-> = z.union([
-  z.nativeEnum(TransactionPaymentSource),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TransactionPaymentSource);

package/src/models/components/transactionstatus.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const TransactionStatus = {
   Processing: "processing",
@@ -27,17 +24,10 @@ export const TransactionStatus$inboundSchema: z.ZodType<
   TransactionStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TransactionStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TransactionStatus);
 /** @internal */
 export const TransactionStatus$outboundSchema: z.ZodType<
-  TransactionStatus,
+  string,
   z.ZodTypeDef,
   TransactionStatus
-> = z.union([
-  z.nativeEnum(TransactionStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TransactionStatus);

package/src/models/components/userstatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const UserStatus = {
   Active: "active",
@@ -17,8 +18,4 @@ export const UserStatus$inboundSchema: z.ZodType<
   UserStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(UserStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(UserStatus);

package/src/models/components/voidstatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const VoidStatus = {
   Succeeded: "succeeded",
@@ -18,8 +19,4 @@ export const VoidStatus$inboundSchema: z.ZodType<
   VoidStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(VoidStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(VoidStatus);

package/src/models/operations/listbuyerpaymentmethods.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { OpenEnum, Unrecognized } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export type ListBuyerPaymentMethodsGlobals = {
   merchantAccountId?: string | undefined;
@@ -54,11 +55,8 @@ export type ListBuyerPaymentMethodsRequest = {
 };
 
 /** @internal */
-export const OrderBy$outboundSchema: z.ZodType<OrderBy, z.ZodTypeDef, OrderBy> =
-  z.union([
-    z.nativeEnum(OrderBy),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+export const OrderBy$outboundSchema: z.ZodType<string, z.ZodTypeDef, OrderBy> =
+  openEnums.outboundSchema(OrderBy);
 
 /** @internal */
 export type ListBuyerPaymentMethodsRequest$Outbound = {

package/src/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/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";