@unified-api/typescript-sdk 2.80.2 → 2.80.3

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

package/src/sdk/models/shared/propertyhrisemployeeemployeeroles.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 PropertyHrisEmployeeEmployeeRoles = {
   Admin: "ADMIN",
@@ -25,17 +22,10 @@ export const PropertyHrisEmployeeEmployeeRoles$inboundSchema: z.ZodType<
   PropertyHrisEmployeeEmployeeRoles,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PropertyHrisEmployeeEmployeeRoles),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PropertyHrisEmployeeEmployeeRoles);
 /** @internal */
 export const PropertyHrisEmployeeEmployeeRoles$outboundSchema: z.ZodType<
-  PropertyHrisEmployeeEmployeeRoles,
+  string,
   z.ZodTypeDef,
   PropertyHrisEmployeeEmployeeRoles
-> = z.union([
-  z.nativeEnum(PropertyHrisEmployeeEmployeeRoles),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(PropertyHrisEmployeeEmployeeRoles);

package/src/sdk/models/shared/propertyintegrationcategories.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 PropertyIntegrationCategories = {
   Passthrough: "passthrough",
@@ -39,8 +40,4 @@ export const PropertyIntegrationCategories$inboundSchema: z.ZodType<
   PropertyIntegrationCategories,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PropertyIntegrationCategories),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PropertyIntegrationCategories);

package/src/sdk/models/shared/propertyintegrationsupportwebhookeventscreated.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 PropertyIntegrationSupportWebhookEventsCreated = {
   Virtual: "virtual",
@@ -19,8 +20,4 @@ export const PropertyIntegrationSupportWebhookEventsCreated$inboundSchema:
     PropertyIntegrationSupportWebhookEventsCreated,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(PropertyIntegrationSupportWebhookEventsCreated),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(PropertyIntegrationSupportWebhookEventsCreated);

package/src/sdk/models/shared/propertyintegrationsupportwebhookeventsdeleted.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 PropertyIntegrationSupportWebhookEventsDeleted = {
   Virtual: "virtual",
@@ -19,8 +20,4 @@ export const PropertyIntegrationSupportWebhookEventsDeleted$inboundSchema:
     PropertyIntegrationSupportWebhookEventsDeleted,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(PropertyIntegrationSupportWebhookEventsDeleted),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(PropertyIntegrationSupportWebhookEventsDeleted);

package/src/sdk/models/shared/propertyintegrationsupportwebhookeventsupdated.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 PropertyIntegrationSupportWebhookEventsUpdated = {
   Virtual: "virtual",
@@ -19,8 +20,4 @@ export const PropertyIntegrationSupportWebhookEventsUpdated$inboundSchema:
     PropertyIntegrationSupportWebhookEventsUpdated,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(PropertyIntegrationSupportWebhookEventsUpdated),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(PropertyIntegrationSupportWebhookEventsUpdated);

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

package/src/sdk/models/shared/propertyscimgroupschemas.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 PropertyScimGroupSchemas = {
   UrnIetfParamsScimSchemasCore20Group:
@@ -22,17 +19,10 @@ export const PropertyScimGroupSchemas$inboundSchema: z.ZodType<
   PropertyScimGroupSchemas,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PropertyScimGroupSchemas),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PropertyScimGroupSchemas);
 /** @internal */
 export const PropertyScimGroupSchemas$outboundSchema: z.ZodType<
-  PropertyScimGroupSchemas,
+  string,
   z.ZodTypeDef,
   PropertyScimGroupSchemas
-> = z.union([
-  z.nativeEnum(PropertyScimGroupSchemas),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(PropertyScimGroupSchemas);

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

package/src/sdk/models/shared/propertyscimuserschemas.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 PropertyScimUserSchemas = {
   UrnIetfParamsScimSchemasCore20User:
@@ -26,17 +23,10 @@ export const PropertyScimUserSchemas$inboundSchema: z.ZodType<
   PropertyScimUserSchemas,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PropertyScimUserSchemas),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PropertyScimUserSchemas);
 /** @internal */
 export const PropertyScimUserSchemas$outboundSchema: z.ZodType<
-  PropertyScimUserSchemas,
+  string,
   z.ZodTypeDef,
   PropertyScimUserSchemas
-> = z.union([
-  z.nativeEnum(PropertyScimUserSchemas),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(PropertyScimUserSchemas);

package/src/sdk/models/shared/propertyscimuserurnietfparamsscimschemasextensionenterprise20user.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";
 import {
@@ -67,25 +64,18 @@ export const PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGe
     PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(
-        PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender,
-      ),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender,
+  );
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender$outboundSchema:
   z.ZodType<
-    PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender,
+    string,
     z.ZodTypeDef,
     PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender
-  > = z.union([
-    z.nativeEnum(
-      PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender,
-    ),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserGender,
+  );
 
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20User$inboundSchema:

package/src/sdk/models/shared/propertyscimuserurnietfparamsscimschemasextensionenterprise20usermanager.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";
 
@@ -43,25 +40,18 @@ export const PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserMa
     PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(
-        PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType,
-      ),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType,
+  );
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType$outboundSchema:
   z.ZodType<
-    PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType,
+    string,
     z.ZodTypeDef,
     PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType
-  > = z.union([
-    z.nativeEnum(
-      PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType,
-    ),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManagerType,
+  );
 
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionEnterprise20UserManager$inboundSchema:

package/src/sdk/models/shared/propertyscimuserurnietfparamsscimschemasextensionlatticeattributes10user.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";
 
@@ -65,20 +62,13 @@ export const Ethnicity$inboundSchema: z.ZodType<
   Ethnicity,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(Ethnicity),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(Ethnicity);
 /** @internal */
 export const Ethnicity$outboundSchema: z.ZodType<
-  Ethnicity,
+  string,
   z.ZodTypeDef,
   Ethnicity
-> = z.union([
-  z.nativeEnum(Ethnicity),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(Ethnicity);
 
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender$inboundSchema:
@@ -86,45 +76,31 @@ export const PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes1
     PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(
-        PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender,
-      ),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender,
+  );
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender$outboundSchema:
   z.ZodType<
-    PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender,
+    string,
     z.ZodTypeDef,
     PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender
-  > = z.union([
-    z.nativeEnum(
-      PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender,
-    ),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10UserGender,
+  );
 
 /** @internal */
 export const SexualOrientation$inboundSchema: z.ZodType<
   SexualOrientation,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(SexualOrientation),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(SexualOrientation);
 /** @internal */
 export const SexualOrientation$outboundSchema: z.ZodType<
-  SexualOrientation,
+  string,
   z.ZodTypeDef,
   SexualOrientation
-> = z.union([
-  z.nativeEnum(SexualOrientation),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(SexualOrientation);
 
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionLatticeAttributes10User$inboundSchema:

package/src/sdk/models/shared/propertyscimuserurnietfparamsscimschemasextensionpeakon20user.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,25 +35,18 @@ export const PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender
     PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(
-        PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender,
-      ),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender,
+  );
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender$outboundSchema:
   z.ZodType<
-    PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender,
+    string,
     z.ZodTypeDef,
     PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender
-  > = z.union([
-    z.nativeEnum(
-      PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender,
-    ),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20UserGender,
+  );
 
 /** @internal */
 export const PropertyScimUserUrnIetfParamsScimSchemasExtensionPeakon20User$inboundSchema:

package/src/sdk/models/shared/propertystoragepermissionroles.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 PropertyStoragePermissionRoles = {
   Owner: "OWNER",
@@ -23,17 +20,10 @@ export const PropertyStoragePermissionRoles$inboundSchema: z.ZodType<
   PropertyStoragePermissionRoles,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PropertyStoragePermissionRoles),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PropertyStoragePermissionRoles);
 /** @internal */
 export const PropertyStoragePermissionRoles$outboundSchema: z.ZodType<
-  PropertyStoragePermissionRoles,
+  string,
   z.ZodTypeDef,
   PropertyStoragePermissionRoles
-> = z.union([
-  z.nativeEnum(PropertyStoragePermissionRoles),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(PropertyStoragePermissionRoles);

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

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 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";
 
@@ -32,11 +33,7 @@ export const PropertyUcCallTelephoneType$inboundSchema: z.ZodType<
   PropertyUcCallTelephoneType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PropertyUcCallTelephoneType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PropertyUcCallTelephoneType);
 
 /** @internal */
 export const PropertyUcCallTelephone$inboundSchema: z.ZodType<

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