@unified-api/typescript-sdk 2.80.2 → 2.80.4

package/src/sdk/models/shared/commerceitemvariant.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 {
@@ -83,40 +80,26 @@ export const SizeUnit$inboundSchema: z.ZodType<
   SizeUnit,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(SizeUnit),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(SizeUnit);
 /** @internal */
 export const SizeUnit$outboundSchema: z.ZodType<
-  SizeUnit,
+  string,
   z.ZodTypeDef,
   SizeUnit
-> = z.union([
-  z.nativeEnum(SizeUnit),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(SizeUnit);
 
 /** @internal */
 export const WeightUnit$inboundSchema: z.ZodType<
   WeightUnit,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(WeightUnit),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(WeightUnit);
 /** @internal */
 export const WeightUnit$outboundSchema: z.ZodType<
-  WeightUnit,
+  string,
   z.ZodTypeDef,
   WeightUnit
-> = z.union([
-  z.nativeEnum(WeightUnit),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(WeightUnit);
 
 /** @internal */
 export const CommerceItemVariant$inboundSchema: z.ZodType<

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

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<