@unified-api/typescript-sdk 2.80.2 → 2.80.4

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -34,20 +31,13 @@ export const ScimAddressType$inboundSchema: z.ZodType<
   ScimAddressType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimAddressType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimAddressType);
 /** @internal */
 export const ScimAddressType$outboundSchema: z.ZodType<
-  ScimAddressType,
+  string,
   z.ZodTypeDef,
   ScimAddressType
-> = z.union([
-  z.nativeEnum(ScimAddressType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimAddressType);
 
 /** @internal */
 export const ScimAddress$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -31,20 +28,13 @@ export const ScimEmailType$inboundSchema: z.ZodType<
   ScimEmailType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimEmailType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimEmailType);
 /** @internal */
 export const ScimEmailType$outboundSchema: z.ZodType<
-  ScimEmailType,
+  string,
   z.ZodTypeDef,
   ScimEmailType
-> = z.union([
-  z.nativeEnum(ScimEmailType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimEmailType);
 
 /** @internal */
 export const ScimEmail$inboundSchema: z.ZodType<

package/src/sdk/models/shared/scimgroupmember.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";
 
@@ -38,40 +35,26 @@ export const Operation$inboundSchema: z.ZodType<
   Operation,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(Operation),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(Operation);
 /** @internal */
 export const Operation$outboundSchema: z.ZodType<
-  Operation,
+  string,
   z.ZodTypeDef,
   Operation
-> = z.union([
-  z.nativeEnum(Operation),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(Operation);
 
 /** @internal */
 export const ScimGroupMemberType$inboundSchema: z.ZodType<
   ScimGroupMemberType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimGroupMemberType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimGroupMemberType);
 /** @internal */
 export const ScimGroupMemberType$outboundSchema: z.ZodType<
-  ScimGroupMemberType,
+  string,
   z.ZodTypeDef,
   ScimGroupMemberType
-> = z.union([
-  z.nativeEnum(ScimGroupMemberType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimGroupMemberType);
 
 /** @internal */
 export const ScimGroupMember$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -36,20 +33,13 @@ export const ScimImsType$inboundSchema: z.ZodType<
   ScimImsType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimImsType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimImsType);
 /** @internal */
 export const ScimImsType$outboundSchema: z.ZodType<
-  ScimImsType,
+  string,
   z.ZodTypeDef,
   ScimImsType
-> = z.union([
-  z.nativeEnum(ScimImsType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimImsType);
 
 /** @internal */
 export const ScimIms$inboundSchema: z.ZodType<ScimIms, z.ZodTypeDef, unknown> =

package/src/sdk/models/shared/scimmanager.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";
 
@@ -35,20 +32,13 @@ export const ScimManagerType$inboundSchema: z.ZodType<
   ScimManagerType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimManagerType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimManagerType);
 /** @internal */
 export const ScimManagerType$outboundSchema: z.ZodType<
-  ScimManagerType,
+  string,
   z.ZodTypeDef,
   ScimManagerType
-> = z.union([
-  z.nativeEnum(ScimManagerType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimManagerType);
 
 /** @internal */
 export const ScimManager$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -34,20 +31,13 @@ export const ScimPhoneNumberType$inboundSchema: z.ZodType<
   ScimPhoneNumberType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimPhoneNumberType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimPhoneNumberType);
 /** @internal */
 export const ScimPhoneNumberType$outboundSchema: z.ZodType<
-  ScimPhoneNumberType,
+  string,
   z.ZodTypeDef,
   ScimPhoneNumberType
-> = z.union([
-  z.nativeEnum(ScimPhoneNumberType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimPhoneNumberType);
 
 /** @internal */
 export const ScimPhoneNumber$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -30,20 +27,13 @@ export const ScimPhotoType$inboundSchema: z.ZodType<
   ScimPhotoType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimPhotoType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimPhotoType);
 /** @internal */
 export const ScimPhotoType$outboundSchema: z.ZodType<
-  ScimPhotoType,
+  string,
   z.ZodTypeDef,
   ScimPhotoType
-> = z.union([
-  z.nativeEnum(ScimPhotoType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimPhotoType);
 
 /** @internal */
 export const ScimPhoto$inboundSchema: z.ZodType<

package/src/sdk/models/shared/scimusergroups.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";
 
@@ -31,20 +28,13 @@ export const ScimUserGroupsType$inboundSchema: z.ZodType<
   ScimUserGroupsType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ScimUserGroupsType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ScimUserGroupsType);
 /** @internal */
 export const ScimUserGroupsType$outboundSchema: z.ZodType<
-  ScimUserGroupsType,
+  string,
   z.ZodTypeDef,
   ScimUserGroupsType
-> = z.union([
-  z.nativeEnum(ScimUserGroupsType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ScimUserGroupsType);
 
 /** @internal */
 export const ScimUserGroups$inboundSchema: z.ZodType<

package/src/sdk/models/shared/storagefile.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 {
@@ -50,20 +47,13 @@ export const StorageFileType$inboundSchema: z.ZodType<
   StorageFileType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(StorageFileType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(StorageFileType);
 /** @internal */
 export const StorageFileType$outboundSchema: z.ZodType<
-  StorageFileType,
+  string,
   z.ZodTypeDef,
   StorageFileType
-> = z.union([
-  z.nativeEnum(StorageFileType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(StorageFileType);
 
 /** @internal */
 export const StorageFile$inboundSchema: z.ZodType<

package/src/sdk/models/shared/taskmetadata.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";
 
@@ -220,20 +217,13 @@ export const TaskMetadataFormat$inboundSchema: z.ZodType<
   TaskMetadataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TaskMetadataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TaskMetadataFormat);
 /** @internal */
 export const TaskMetadataFormat$outboundSchema: z.ZodType<
-  TaskMetadataFormat,
+  string,
   z.ZodTypeDef,
   TaskMetadataFormat
-> = z.union([
-  z.nativeEnum(TaskMetadataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TaskMetadataFormat);
 
 /** @internal */
 export const TaskMetadataSchemas1$inboundSchema: z.ZodType<

package/src/sdk/models/shared/tasktask.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 {
@@ -58,20 +55,13 @@ export const TaskTaskStatus$inboundSchema: z.ZodType<
   TaskTaskStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TaskTaskStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TaskTaskStatus);
 /** @internal */
 export const TaskTaskStatus$outboundSchema: z.ZodType<
-  TaskTaskStatus,
+  string,
   z.ZodTypeDef,
   TaskTaskStatus
-> = z.union([
-  z.nativeEnum(TaskTaskStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TaskTaskStatus);
 
 /** @internal */
 export const TaskTask$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -29,20 +26,13 @@ export const TicketingEmailType$inboundSchema: z.ZodType<
   TicketingEmailType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TicketingEmailType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TicketingEmailType);
 /** @internal */
 export const TicketingEmailType$outboundSchema: z.ZodType<
-  TicketingEmailType,
+  string,
   z.ZodTypeDef,
   TicketingEmailType
-> = z.union([
-  z.nativeEnum(TicketingEmailType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TicketingEmailType);
 
 /** @internal */
 export const TicketingEmail$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -31,20 +28,13 @@ export const TicketingTelephoneType$inboundSchema: z.ZodType<
   TicketingTelephoneType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TicketingTelephoneType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TicketingTelephoneType);
 /** @internal */
 export const TicketingTelephoneType$outboundSchema: z.ZodType<
-  TicketingTelephoneType,
+  string,
   z.ZodTypeDef,
   TicketingTelephoneType
-> = z.union([
-  z.nativeEnum(TicketingTelephoneType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TicketingTelephoneType);
 
 /** @internal */
 export const TicketingTelephone$inboundSchema: z.ZodType<

package/src/sdk/models/shared/ticketingticket.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";
 
@@ -44,20 +41,13 @@ export const TicketingTicketStatus$inboundSchema: z.ZodType<
   TicketingTicketStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TicketingTicketStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TicketingTicketStatus);
 /** @internal */
 export const TicketingTicketStatus$outboundSchema: z.ZodType<
-  TicketingTicketStatus,
+  string,
   z.ZodTypeDef,
   TicketingTicketStatus
-> = z.union([
-  z.nativeEnum(TicketingTicketStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TicketingTicketStatus);
 
 /** @internal */
 export const TicketingTicket$inboundSchema: z.ZodType<

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -29,20 +26,13 @@ export const UcEmailType$inboundSchema: z.ZodType<
   UcEmailType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(UcEmailType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(UcEmailType);
 /** @internal */
 export const UcEmailType$outboundSchema: z.ZodType<
-  UcEmailType,
+  string,
   z.ZodTypeDef,
   UcEmailType
-> = z.union([
-  z.nativeEnum(UcEmailType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(UcEmailType);
 
 /** @internal */
 export const UcEmail$inboundSchema: z.ZodType<UcEmail, z.ZodTypeDef, unknown> =

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

@@ -4,11 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -31,20 +28,13 @@ export const UcTelephoneType$inboundSchema: z.ZodType<
   UcTelephoneType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(UcTelephoneType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(UcTelephoneType);
 /** @internal */
 export const UcTelephoneType$outboundSchema: z.ZodType<
-  UcTelephoneType,
+  string,
   z.ZodTypeDef,
   UcTelephoneType
-> = z.union([
-  z.nativeEnum(UcTelephoneType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(UcTelephoneType);
 
 /** @internal */
 export const UcTelephone$inboundSchema: z.ZodType<

package/src/sdk/models/shared/verificationpackage.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";
 import {
@@ -64,11 +65,7 @@ export const VerificationPackageType$inboundSchema: z.ZodType<
   VerificationPackageType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(VerificationPackageType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(VerificationPackageType);
 
 /** @internal */
 export const VerificationPackage$inboundSchema: z.ZodType<