@unified-api/typescript-sdk 2.72.5 → 2.73.1

package/src/sdk/models/shared/accountingcontactpaymentmethod.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";
 
@@ -19,7 +23,7 @@ export const AccountingContactPaymentMethodType = {
   Wire: "WIRE",
   Check: "CHECK",
 } as const;
-export type AccountingContactPaymentMethodType = ClosedEnum<
+export type AccountingContactPaymentMethodType = OpenEnum<
   typeof AccountingContactPaymentMethodType
 >;
 
@@ -31,14 +35,25 @@ export type AccountingContactPaymentMethod = {
 };
 
 /** @internal */
-export const AccountingContactPaymentMethodType$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingContactPaymentMethodType
-> = z.nativeEnum(AccountingContactPaymentMethodType);
+export const AccountingContactPaymentMethodType$inboundSchema: z.ZodType<
+  AccountingContactPaymentMethodType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingContactPaymentMethodType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingContactPaymentMethodType$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingContactPaymentMethodType
-> = AccountingContactPaymentMethodType$inboundSchema;
+export const AccountingContactPaymentMethodType$outboundSchema: z.ZodType<
+  AccountingContactPaymentMethodType,
+  z.ZodTypeDef,
+  AccountingContactPaymentMethodType
+> = z.union([
+  z.nativeEnum(AccountingContactPaymentMethodType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/accountingemail.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";
 
@@ -13,7 +17,7 @@ export const AccountingEmailType = {
   Home: "HOME",
   Other: "OTHER",
 } as const;
-export type AccountingEmailType = ClosedEnum<typeof AccountingEmailType>;
+export type AccountingEmailType = OpenEnum<typeof AccountingEmailType>;
 
 export type AccountingEmail = {
   email?: string | undefined;
@@ -21,14 +25,25 @@ export type AccountingEmail = {
 };
 
 /** @internal */
-export const AccountingEmailType$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingEmailType
-> = z.nativeEnum(AccountingEmailType);
+export const AccountingEmailType$inboundSchema: z.ZodType<
+  AccountingEmailType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingEmailType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingEmailType$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingEmailType
-> = AccountingEmailType$inboundSchema;
+export const AccountingEmailType$outboundSchema: z.ZodType<
+  AccountingEmailType,
+  z.ZodTypeDef,
+  AccountingEmailType
+> = z.union([
+  z.nativeEnum(AccountingEmailType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/accountinginvoice.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 {
@@ -25,9 +29,7 @@ export const PaymentCollectionMethod = {
   SendInvoice: "send_invoice",
   ChargeAutomatically: "charge_automatically",
 } as const;
-export type PaymentCollectionMethod = ClosedEnum<
-  typeof PaymentCollectionMethod
->;
+export type PaymentCollectionMethod = OpenEnum<typeof PaymentCollectionMethod>;
 
 export const AccountingInvoiceStatus = {
   Draft: "DRAFT",
@@ -38,16 +40,14 @@ export const AccountingInvoiceStatus = {
   PartiallyRefunded: "PARTIALLY_REFUNDED",
   Refunded: "REFUNDED",
 } as const;
-export type AccountingInvoiceStatus = ClosedEnum<
-  typeof AccountingInvoiceStatus
->;
+export type AccountingInvoiceStatus = OpenEnum<typeof AccountingInvoiceStatus>;
 
 export const AccountingInvoiceType = {
   Bill: "BILL",
   Invoice: "INVOICE",
   Creditmemo: "CREDITMEMO",
 } as const;
-export type AccountingInvoiceType = ClosedEnum<typeof AccountingInvoiceType>;
+export type AccountingInvoiceType = OpenEnum<typeof AccountingInvoiceType>;
 
 export type AccountingInvoice = {
   attachments?: Array<AccountingAttachment> | undefined;
@@ -81,14 +81,25 @@ export type AccountingInvoice = {
 };
 
 /** @internal */
-export const PaymentCollectionMethod$inboundSchema: z.ZodNativeEnum<
-  typeof PaymentCollectionMethod
-> = z.nativeEnum(PaymentCollectionMethod);
+export const PaymentCollectionMethod$inboundSchema: z.ZodType<
+  PaymentCollectionMethod,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(PaymentCollectionMethod),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const PaymentCollectionMethod$outboundSchema: z.ZodNativeEnum<
-  typeof PaymentCollectionMethod
-> = PaymentCollectionMethod$inboundSchema;
+export const PaymentCollectionMethod$outboundSchema: z.ZodType<
+  PaymentCollectionMethod,
+  z.ZodTypeDef,
+  PaymentCollectionMethod
+> = z.union([
+  z.nativeEnum(PaymentCollectionMethod),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -102,14 +113,25 @@ export namespace PaymentCollectionMethod$ {
 }
 
 /** @internal */
-export const AccountingInvoiceStatus$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingInvoiceStatus
-> = z.nativeEnum(AccountingInvoiceStatus);
+export const AccountingInvoiceStatus$inboundSchema: z.ZodType<
+  AccountingInvoiceStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingInvoiceStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingInvoiceStatus$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingInvoiceStatus
-> = AccountingInvoiceStatus$inboundSchema;
+export const AccountingInvoiceStatus$outboundSchema: z.ZodType<
+  AccountingInvoiceStatus,
+  z.ZodTypeDef,
+  AccountingInvoiceStatus
+> = z.union([
+  z.nativeEnum(AccountingInvoiceStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -123,14 +145,25 @@ export namespace AccountingInvoiceStatus$ {
 }
 
 /** @internal */
-export const AccountingInvoiceType$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingInvoiceType
-> = z.nativeEnum(AccountingInvoiceType);
+export const AccountingInvoiceType$inboundSchema: z.ZodType<
+  AccountingInvoiceType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingInvoiceType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingInvoiceType$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingInvoiceType
-> = AccountingInvoiceType$inboundSchema;
+export const AccountingInvoiceType$outboundSchema: z.ZodType<
+  AccountingInvoiceType,
+  z.ZodTypeDef,
+  AccountingInvoiceType
+> = z.union([
+  z.nativeEnum(AccountingInvoiceType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/accountingorder.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 {
@@ -36,13 +40,13 @@ export const AccountingOrderStatus = {
   PartiallyRefunded: "PARTIALLY_REFUNDED",
   Refunded: "REFUNDED",
 } as const;
-export type AccountingOrderStatus = ClosedEnum<typeof AccountingOrderStatus>;
+export type AccountingOrderStatus = OpenEnum<typeof AccountingOrderStatus>;
 
 export const AccountingOrderType = {
   Sales: "SALES",
   Purchase: "PURCHASE",
 } as const;
-export type AccountingOrderType = ClosedEnum<typeof AccountingOrderType>;
+export type AccountingOrderType = OpenEnum<typeof AccountingOrderType>;
 
 export type AccountingOrder = {
   accountId?: string | undefined;
@@ -62,14 +66,25 @@ export type AccountingOrder = {
 };
 
 /** @internal */
-export const AccountingOrderStatus$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingOrderStatus
-> = z.nativeEnum(AccountingOrderStatus);
+export const AccountingOrderStatus$inboundSchema: z.ZodType<
+  AccountingOrderStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingOrderStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingOrderStatus$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingOrderStatus
-> = AccountingOrderStatus$inboundSchema;
+export const AccountingOrderStatus$outboundSchema: z.ZodType<
+  AccountingOrderStatus,
+  z.ZodTypeDef,
+  AccountingOrderStatus
+> = z.union([
+  z.nativeEnum(AccountingOrderStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -83,14 +98,25 @@ export namespace AccountingOrderStatus$ {
 }
 
 /** @internal */
-export const AccountingOrderType$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingOrderType
-> = z.nativeEnum(AccountingOrderType);
+export const AccountingOrderType$inboundSchema: z.ZodType<
+  AccountingOrderType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingOrderType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingOrderType$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingOrderType
-> = AccountingOrderType$inboundSchema;
+export const AccountingOrderType$outboundSchema: z.ZodType<
+  AccountingOrderType,
+  z.ZodTypeDef,
+  AccountingOrderType
+> = z.union([
+  z.nativeEnum(AccountingOrderType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/accountingreport.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 {
@@ -32,7 +36,7 @@ export const AccountingReportType = {
   BalanceSheet: "BALANCE_SHEET",
   ProfitAndLoss: "PROFIT_AND_LOSS",
 } as const;
-export type AccountingReportType = ClosedEnum<typeof AccountingReportType>;
+export type AccountingReportType = OpenEnum<typeof AccountingReportType>;
 
 export type AccountingReport = {
   balanceSheet?: PropertyAccountingReportBalanceSheet | undefined;
@@ -50,14 +54,25 @@ export type AccountingReport = {
 };
 
 /** @internal */
-export const AccountingReportType$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingReportType
-> = z.nativeEnum(AccountingReportType);
+export const AccountingReportType$inboundSchema: z.ZodType<
+  AccountingReportType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingReportType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingReportType$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingReportType
-> = AccountingReportType$inboundSchema;
+export const AccountingReportType$outboundSchema: z.ZodType<
+  AccountingReportType,
+  z.ZodTypeDef,
+  AccountingReportType
+> = z.union([
+  z.nativeEnum(AccountingReportType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/accountingtelephone.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";
 
@@ -15,9 +19,7 @@ export const AccountingTelephoneType = {
   Fax: "FAX",
   Mobile: "MOBILE",
 } as const;
-export type AccountingTelephoneType = ClosedEnum<
-  typeof AccountingTelephoneType
->;
+export type AccountingTelephoneType = OpenEnum<typeof AccountingTelephoneType>;
 
 export type AccountingTelephone = {
   telephone?: string | undefined;
@@ -25,14 +27,25 @@ export type AccountingTelephone = {
 };
 
 /** @internal */
-export const AccountingTelephoneType$inboundSchema: z.ZodNativeEnum<
-  typeof AccountingTelephoneType
-> = z.nativeEnum(AccountingTelephoneType);
+export const AccountingTelephoneType$inboundSchema: z.ZodType<
+  AccountingTelephoneType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AccountingTelephoneType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AccountingTelephoneType$outboundSchema: z.ZodNativeEnum<
-  typeof AccountingTelephoneType
-> = AccountingTelephoneType$inboundSchema;
+export const AccountingTelephoneType$outboundSchema: z.ZodType<
+  AccountingTelephoneType,
+  z.ZodTypeDef,
+  AccountingTelephoneType
+> = z.union([
+  z.nativeEnum(AccountingTelephoneType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/apicall.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";
 
@@ -14,7 +18,7 @@ export const ApiCallType = {
   Webhook: "webhook",
   Inbound: "inbound",
 } as const;
-export type ApiCallType = ClosedEnum<typeof ApiCallType>;
+export type ApiCallType = OpenEnum<typeof ApiCallType>;
 
 export type ApiCall = {
   connectionId?: string | undefined;
@@ -37,12 +41,25 @@ export type ApiCall = {
 };
 
 /** @internal */
-export const ApiCallType$inboundSchema: z.ZodNativeEnum<typeof ApiCallType> = z
-  .nativeEnum(ApiCallType);
+export const ApiCallType$inboundSchema: z.ZodType<
+  ApiCallType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ApiCallType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ApiCallType$outboundSchema: z.ZodNativeEnum<typeof ApiCallType> =
-  ApiCallType$inboundSchema;
+export const ApiCallType$outboundSchema: z.ZodType<
+  ApiCallType,
+  z.ZodTypeDef,
+  ApiCallType
+> = z.union([
+  z.nativeEnum(ApiCallType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/atsactivity.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 {
@@ -26,7 +30,7 @@ export const AtsActivityType = {
   Task: "TASK",
   Email: "EMAIL",
 } as const;
-export type AtsActivityType = ClosedEnum<typeof AtsActivityType>;
+export type AtsActivityType = OpenEnum<typeof AtsActivityType>;
 
 export type AtsActivity = {
   applicationId?: string | undefined;
@@ -58,14 +62,25 @@ export type AtsActivity = {
 };
 
 /** @internal */
-export const AtsActivityType$inboundSchema: z.ZodNativeEnum<
-  typeof AtsActivityType
-> = z.nativeEnum(AtsActivityType);
+export const AtsActivityType$inboundSchema: z.ZodType<
+  AtsActivityType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AtsActivityType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AtsActivityType$outboundSchema: z.ZodNativeEnum<
-  typeof AtsActivityType
-> = AtsActivityType$inboundSchema;
+export const AtsActivityType$outboundSchema: z.ZodType<
+  AtsActivityType,
+  z.ZodTypeDef,
+  AtsActivityType
+> = z.union([
+  z.nativeEnum(AtsActivityType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/atsapplication.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 {
@@ -43,7 +47,7 @@ export const AtsApplicationStatus = {
   Declined: "DECLINED",
   Withdrawn: "WITHDRAWN",
 } as const;
-export type AtsApplicationStatus = ClosedEnum<typeof AtsApplicationStatus>;
+export type AtsApplicationStatus = OpenEnum<typeof AtsApplicationStatus>;
 
 export type AtsApplication = {
   answers?: Array<AtsApplicationAnswer> | undefined;
@@ -65,14 +69,25 @@ export type AtsApplication = {
 };
 
 /** @internal */
-export const AtsApplicationStatus$inboundSchema: z.ZodNativeEnum<
-  typeof AtsApplicationStatus
-> = z.nativeEnum(AtsApplicationStatus);
+export const AtsApplicationStatus$inboundSchema: z.ZodType<
+  AtsApplicationStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(AtsApplicationStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const AtsApplicationStatus$outboundSchema: z.ZodNativeEnum<
-  typeof AtsApplicationStatus
-> = AtsApplicationStatus$inboundSchema;
+export const AtsApplicationStatus$outboundSchema: z.ZodType<
+  AtsApplicationStatus,
+  z.ZodTypeDef,
+  AtsApplicationStatus
+> = z.union([
+  z.nativeEnum(AtsApplicationStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/sdk/models/shared/atscandidate.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 {
@@ -53,7 +57,7 @@ export const Origin = {
   Sourced: "SOURCED",
   University: "UNIVERSITY",
 } as const;
-export type Origin = ClosedEnum<typeof Origin>;
+export type Origin = OpenEnum<typeof Origin>;
 
 export type AtsCandidate = {
   address?: PropertyAtsCandidateAddress | undefined;
@@ -86,12 +90,18 @@ export type AtsCandidate = {
 };
 
 /** @internal */
-export const Origin$inboundSchema: z.ZodNativeEnum<typeof Origin> = z
-  .nativeEnum(Origin);
+export const Origin$inboundSchema: z.ZodType<Origin, z.ZodTypeDef, unknown> = z
+  .union([
+    z.nativeEnum(Origin),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const Origin$outboundSchema: z.ZodNativeEnum<typeof Origin> =
-  Origin$inboundSchema;
+export const Origin$outboundSchema: z.ZodType<Origin, z.ZodTypeDef, Origin> = z
+  .union([
+    z.nativeEnum(Origin),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
 
 /**
  * @internal