@unified-api/typescript-sdk 2.80.2 → 2.80.4

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

package/src/sdk/models/shared/atsjob.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 {
@@ -115,6 +112,7 @@ export type AtsJob = {
   raw?: { [k: string]: any } | undefined;
   recruiterIds?: Array<string> | undefined;
   remote?: boolean | undefined;
+  skills?: Array<string> | undefined;
   status?: AtsJobStatus | undefined;
   updatedAt?: Date | undefined;
 };
@@ -124,40 +122,26 @@ export const EmploymentType$inboundSchema: z.ZodType<
   EmploymentType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(EmploymentType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(EmploymentType);
 /** @internal */
 export const EmploymentType$outboundSchema: z.ZodType<
-  EmploymentType,
+  string,
   z.ZodTypeDef,
   EmploymentType
-> = z.union([
-  z.nativeEnum(EmploymentType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(EmploymentType);
 
 /** @internal */
 export const AtsJobStatus$inboundSchema: z.ZodType<
   AtsJobStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AtsJobStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AtsJobStatus);
 /** @internal */
 export const AtsJobStatus$outboundSchema: z.ZodType<
-  AtsJobStatus,
+  string,
   z.ZodTypeDef,
   AtsJobStatus
-> = z.union([
-  z.nativeEnum(AtsJobStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(AtsJobStatus);
 
 /** @internal */
 export const AtsJob$inboundSchema: z.ZodType<AtsJob, z.ZodTypeDef, unknown> = z
@@ -189,6 +173,7 @@ export const AtsJob$inboundSchema: z.ZodType<AtsJob, z.ZodTypeDef, unknown> = z
     raw: z.record(z.any()).optional(),
     recruiter_ids: z.array(z.string()).optional(),
     remote: z.boolean().optional(),
+    skills: z.array(z.string()).optional(),
     status: AtsJobStatus$inboundSchema.optional(),
     updated_at: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
@@ -235,6 +220,7 @@ export type AtsJob$Outbound = {
   raw?: { [k: string]: any } | undefined;
   recruiter_ids?: Array<string> | undefined;
   remote?: boolean | undefined;
+  skills?: Array<string> | undefined;
   status?: string | undefined;
   updated_at?: string | undefined;
 };
@@ -269,6 +255,7 @@ export const AtsJob$outboundSchema: z.ZodType<
   raw: z.record(z.any()).optional(),
   recruiterIds: z.array(z.string()).optional(),
   remote: z.boolean().optional(),
+  skills: z.array(z.string()).optional(),
   status: AtsJobStatus$outboundSchema.optional(),
   updatedAt: z.date().transform(v => v.toISOString()).optional(),
 }).transform((v) => {

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

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

package/src/sdk/models/shared/atsmetadata.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";
 
@@ -192,17 +189,11 @@ export function extraDataFromJSON(
 }
 
 /** @internal */
-export const Format$inboundSchema: z.ZodType<Format, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Format),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Format$inboundSchema: z.ZodType<Format, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Format);
 /** @internal */
-export const Format$outboundSchema: z.ZodType<Format, z.ZodTypeDef, Format> = z
-  .union([
-    z.nativeEnum(Format),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+export const Format$outboundSchema: z.ZodType<string, z.ZodTypeDef, Format> =
+  openEnums.outboundSchema(Format);
 
 /** @internal */
 export const AtsMetadata1$inboundSchema: z.ZodType<

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

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

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

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

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

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

@@ -12,6 +12,7 @@ export type CalendarCalendar = {
   createdAt?: Date | undefined;
   description?: string | undefined;
   id?: string | undefined;
+  isPrimary?: boolean | undefined;
   name: string;
   primary?: boolean | undefined;
   raw?: { [k: string]: any } | undefined;
@@ -29,6 +30,7 @@ export const CalendarCalendar$inboundSchema: z.ZodType<
     .optional(),
   description: z.string().optional(),
   id: z.string().optional(),
+  is_primary: z.boolean().optional(),
   name: z.string(),
   primary: z.boolean().optional(),
   raw: z.record(z.any()).optional(),
@@ -38,6 +40,7 @@ export const CalendarCalendar$inboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
+    "is_primary": "isPrimary",
     "updated_at": "updatedAt",
   });
 });
@@ -46,6 +49,7 @@ export type CalendarCalendar$Outbound = {
   created_at?: string | undefined;
   description?: string | undefined;
   id?: string | undefined;
+  is_primary?: boolean | undefined;
   name: string;
   primary?: boolean | undefined;
   raw?: { [k: string]: any } | undefined;
@@ -62,6 +66,7 @@ export const CalendarCalendar$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   description: z.string().optional(),
   id: z.string().optional(),
+  isPrimary: z.boolean().optional(),
   name: z.string(),
   primary: z.boolean().optional(),
   raw: z.record(z.any()).optional(),
@@ -70,6 +75,7 @@ export const CalendarCalendar$outboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",
+    isPrimary: "is_primary",
     updatedAt: "updated_at",
   });
 });

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

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

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

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