@unified-api/typescript-sdk 2.80.2 → 2.80.4

package/src/sdk/models/shared/accountinginvoice.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 {
@@ -89,60 +86,39 @@ export const AccountingInvoicePaymentCollectionMethod$inboundSchema: z.ZodType<
   AccountingInvoicePaymentCollectionMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AccountingInvoicePaymentCollectionMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AccountingInvoicePaymentCollectionMethod);
 /** @internal */
 export const AccountingInvoicePaymentCollectionMethod$outboundSchema: z.ZodType<
-  AccountingInvoicePaymentCollectionMethod,
+  string,
   z.ZodTypeDef,
   AccountingInvoicePaymentCollectionMethod
-> = z.union([
-  z.nativeEnum(AccountingInvoicePaymentCollectionMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(AccountingInvoicePaymentCollectionMethod);
 
 /** @internal */
 export const AccountingInvoiceStatus$inboundSchema: z.ZodType<
   AccountingInvoiceStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AccountingInvoiceStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AccountingInvoiceStatus);
 /** @internal */
 export const AccountingInvoiceStatus$outboundSchema: z.ZodType<
-  AccountingInvoiceStatus,
+  string,
   z.ZodTypeDef,
   AccountingInvoiceStatus
-> = z.union([
-  z.nativeEnum(AccountingInvoiceStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(AccountingInvoiceStatus);
 
 /** @internal */
 export const AccountingInvoiceType$inboundSchema: z.ZodType<
   AccountingInvoiceType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AccountingInvoiceType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AccountingInvoiceType);
 /** @internal */
 export const AccountingInvoiceType$outboundSchema: z.ZodType<
-  AccountingInvoiceType,
+  string,
   z.ZodTypeDef,
   AccountingInvoiceType
-> = z.union([
-  z.nativeEnum(AccountingInvoiceType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(AccountingInvoiceType);
 
 /** @internal */
 export const AccountingInvoice$inboundSchema: z.ZodType<

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

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

package/src/sdk/models/shared/accountingreport.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 {
@@ -28,6 +29,9 @@ export const AccountingReportType = {
 } as const;
 export type AccountingReportType = OpenEnum<typeof AccountingReportType>;
 
+/**
+ * @deprecated; use either AccountingProfitandloss, AccountingTrialbalance, AccountingBalancesheet, or AccountingCashflow instead
+ */
 export type AccountingReport = {
   balanceSheet?: PropertyAccountingReportBalanceSheet | undefined;
   createdAt?: Date | undefined;
@@ -48,11 +52,7 @@ export const AccountingReportType$inboundSchema: z.ZodType<
   AccountingReportType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AccountingReportType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AccountingReportType);
 
 /** @internal */
 export const AccountingReport$inboundSchema: z.ZodType<

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

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

package/src/sdk/models/shared/apicall.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";
 
@@ -13,6 +14,7 @@ export const ApiCallType = {
   Login: "login",
   Webhook: "webhook",
   Inbound: "inbound",
+  Mcp: "mcp",
 } as const;
 export type ApiCallType = OpenEnum<typeof ApiCallType>;
 
@@ -41,11 +43,7 @@ export const ApiCallType$inboundSchema: z.ZodType<
   ApiCallType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ApiCallType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ApiCallType);
 
 /** @internal */
 export const ApiCall$inboundSchema: z.ZodType<ApiCall, z.ZodTypeDef, unknown> =

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

package/src/sdk/models/shared/atsapplication.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 {
@@ -66,6 +63,7 @@ export type AtsApplication = {
   source?: string | undefined;
   status?: AtsApplicationStatus | undefined;
   updatedAt?: Date | undefined;
+  userId?: string | undefined;
 };
 
 /** @internal */
@@ -73,20 +71,13 @@ export const AtsApplicationStatus$inboundSchema: z.ZodType<
   AtsApplicationStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AtsApplicationStatus),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AtsApplicationStatus);
 /** @internal */
 export const AtsApplicationStatus$outboundSchema: z.ZodType<
-  AtsApplicationStatus,
+  string,
   z.ZodTypeDef,
   AtsApplicationStatus
-> = z.union([
-  z.nativeEnum(AtsApplicationStatus),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(AtsApplicationStatus);
 
 /** @internal */
 export const AtsApplication$inboundSchema: z.ZodType<
@@ -115,6 +106,7 @@ export const AtsApplication$inboundSchema: z.ZodType<
   status: AtsApplicationStatus$inboundSchema.optional(),
   updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
+  user_id: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     "applied_at": "appliedAt",
@@ -126,6 +118,7 @@ export const AtsApplication$inboundSchema: z.ZodType<
     "rejected_at": "rejectedAt",
     "rejected_reason": "rejectedReason",
     "updated_at": "updatedAt",
+    "user_id": "userId",
   });
 });
 /** @internal */
@@ -146,6 +139,7 @@ export type AtsApplication$Outbound = {
   source?: string | undefined;
   status?: string | undefined;
   updated_at?: string | undefined;
+  user_id?: string | undefined;
 };
 
 /** @internal */
@@ -170,6 +164,7 @@ export const AtsApplication$outboundSchema: z.ZodType<
   source: z.string().optional(),
   status: AtsApplicationStatus$outboundSchema.optional(),
   updatedAt: z.date().transform(v => v.toISOString()).optional(),
+  userId: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     appliedAt: "applied_at",
@@ -181,6 +176,7 @@ export const AtsApplication$outboundSchema: z.ZodType<
     rejectedAt: "rejected_at",
     rejectedReason: "rejected_reason",
     updatedAt: "updated_at",
+    userId: "user_id",
   });
 });
 

package/src/sdk/models/shared/atscandidate.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 {
@@ -92,17 +89,11 @@ export type AtsCandidate = {
 };
 
 /** @internal */
-export const Origin$inboundSchema: z.ZodType<Origin, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(Origin),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+export const Origin$inboundSchema: z.ZodType<Origin, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Origin);
 /** @internal */
-export const Origin$outboundSchema: z.ZodType<Origin, z.ZodTypeDef, Origin> = z
-  .union([
-    z.nativeEnum(Origin),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+export const Origin$outboundSchema: z.ZodType<string, z.ZodTypeDef, Origin> =
+  openEnums.outboundSchema(Origin);
 
 /** @internal */
 export const AtsCandidate$inboundSchema: z.ZodType<

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

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

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

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