@unified-api/typescript-sdk 2.80.2 → 2.80.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/sdk/models/shared/propertycalendarrecordingtranscriptattendee.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";
 
@@ -32,11 +33,9 @@ export const PropertyCalendarRecordingTranscriptAttendeeStatus$inboundSchema:
     PropertyCalendarRecordingTranscriptAttendeeStatus,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(PropertyCalendarRecordingTranscriptAttendeeStatus),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    PropertyCalendarRecordingTranscriptAttendeeStatus,
+  );
 
 /** @internal */
 export const PropertyCalendarRecordingTranscriptAttendee$inboundSchema:

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

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