@unified-api/typescript-sdk 2.80.2 → 2.80.3

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

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

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

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

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

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

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

package/src/sdk/models/shared/enrichemail.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";
 
@@ -27,11 +28,7 @@ export const EnrichEmailType$inboundSchema: z.ZodType<
   EnrichEmailType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(EnrichEmailType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(EnrichEmailType);
 
 /** @internal */
 export const EnrichEmail$inboundSchema: z.ZodType<

package/src/sdk/models/shared/enrichperson.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 { EnrichEmail, EnrichEmail$inboundSchema } from "./enrichemail.js";
@@ -70,11 +71,8 @@ export type EnrichPerson = {
 };
 
 /** @internal */
-export const Gender$inboundSchema: z.ZodType<Gender, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Gender),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Gender$inboundSchema: z.ZodType<Gender, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Gender);
 
 /** @internal */
 export const EnrichPerson$inboundSchema: z.ZodType<

package/src/sdk/models/shared/enrichtelephone.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";
 
@@ -27,11 +28,7 @@ export const EnrichTelephoneType$inboundSchema: z.ZodType<
   EnrichTelephoneType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(EnrichTelephoneType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(EnrichTelephoneType);
 
 /** @internal */
 export const EnrichTelephone$inboundSchema: z.ZodType<

package/src/sdk/models/shared/genaicontent.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";
 
@@ -24,18 +21,11 @@ export type GenaiContent = {
 };
 
 /** @internal */
-export const Role$inboundSchema: z.ZodType<Role, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Role),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Role$inboundSchema: z.ZodType<Role, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Role);
 /** @internal */
-export const Role$outboundSchema: z.ZodType<Role, z.ZodTypeDef, Role> = z.union(
-  [
-    z.nativeEnum(Role),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ],
-);
+export const Role$outboundSchema: z.ZodType<string, z.ZodTypeDef, Role> =
+  openEnums.outboundSchema(Role);
 
 /** @internal */
 export const GenaiContent$inboundSchema: z.ZodType<

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

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

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

package/src/sdk/models/shared/hrisemployee.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 {
@@ -148,80 +145,52 @@ export const EmploymentStatus$inboundSchema: z.ZodType<
   EmploymentStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(EmploymentStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(EmploymentStatus);
 /** @internal */
 export const EmploymentStatus$outboundSchema: z.ZodType<
-  EmploymentStatus,
+  string,
   z.ZodTypeDef,
   EmploymentStatus
-> = z.union([
-  z.nativeEnum(EmploymentStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(EmploymentStatus);
 
 /** @internal */
 export const HrisEmployeeEmploymentType$inboundSchema: z.ZodType<
   HrisEmployeeEmploymentType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(HrisEmployeeEmploymentType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(HrisEmployeeEmploymentType);
 /** @internal */
 export const HrisEmployeeEmploymentType$outboundSchema: z.ZodType<
-  HrisEmployeeEmploymentType,
+  string,
   z.ZodTypeDef,
   HrisEmployeeEmploymentType
-> = z.union([
-  z.nativeEnum(HrisEmployeeEmploymentType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(HrisEmployeeEmploymentType);
 
 /** @internal */
 export const HrisEmployeeGender$inboundSchema: z.ZodType<
   HrisEmployeeGender,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(HrisEmployeeGender),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(HrisEmployeeGender);
 /** @internal */
 export const HrisEmployeeGender$outboundSchema: z.ZodType<
-  HrisEmployeeGender,
+  string,
   z.ZodTypeDef,
   HrisEmployeeGender
-> = z.union([
-  z.nativeEnum(HrisEmployeeGender),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(HrisEmployeeGender);
 
 /** @internal */
 export const MaritalStatus$inboundSchema: z.ZodType<
   MaritalStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MaritalStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MaritalStatus);
 /** @internal */
 export const MaritalStatus$outboundSchema: z.ZodType<
-  MaritalStatus,
+  string,
   z.ZodTypeDef,
   MaritalStatus
-> = z.union([
-  z.nativeEnum(MaritalStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(MaritalStatus);
 
 /** @internal */
 export const HrisEmployee$inboundSchema: z.ZodType<

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