cribl-control-plane 0.4.0-beta.2 → 0.4.0-beta.4

package/src/models/inputwineventlogs.ts

@@ -4,12 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -272,40 +268,26 @@ export const InputWinEventLogsMode$inboundSchema: z.ZodType<
   InputWinEventLogsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWinEventLogsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWinEventLogsMode);
 /** @internal */
 export const InputWinEventLogsMode$outboundSchema: z.ZodType<
-  InputWinEventLogsMode,
+  string,
   z.ZodTypeDef,
   InputWinEventLogsMode
-> = z.union([
-  z.nativeEnum(InputWinEventLogsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWinEventLogsMode);
 
 /** @internal */
 export const InputWinEventLogsCompression$inboundSchema: z.ZodType<
   InputWinEventLogsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWinEventLogsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWinEventLogsCompression);
 /** @internal */
 export const InputWinEventLogsCompression$outboundSchema: z.ZodType<
-  InputWinEventLogsCompression,
+  string,
   z.ZodTypeDef,
   InputWinEventLogsCompression
-> = z.union([
-  z.nativeEnum(InputWinEventLogsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWinEventLogsCompression);
 
 /** @internal */
 export const InputWinEventLogsPqControls$inboundSchema: z.ZodType<
@@ -409,40 +391,26 @@ export const ReadMode$inboundSchema: z.ZodType<
   ReadMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ReadMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ReadMode);
 /** @internal */
 export const ReadMode$outboundSchema: z.ZodType<
-  ReadMode,
+  string,
   z.ZodTypeDef,
   ReadMode
-> = z.union([
-  z.nativeEnum(ReadMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ReadMode);
 
 /** @internal */
 export const EventFormat$inboundSchema: z.ZodType<
   EventFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(EventFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(EventFormat);
 /** @internal */
 export const EventFormat$outboundSchema: z.ZodType<
-  EventFormat,
+  string,
   z.ZodTypeDef,
   EventFormat
-> = z.union([
-  z.nativeEnum(EventFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(EventFormat);
 
 /** @internal */
 export const InputWinEventLogsMetadatum$inboundSchema: z.ZodType<

package/src/models/inputwiz.ts

@@ -4,12 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -378,40 +374,26 @@ export const InputWizMode$inboundSchema: z.ZodType<
   InputWizMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizMode);
 /** @internal */
 export const InputWizMode$outboundSchema: z.ZodType<
-  InputWizMode,
+  string,
   z.ZodTypeDef,
   InputWizMode
-> = z.union([
-  z.nativeEnum(InputWizMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizMode);
 
 /** @internal */
 export const InputWizCompression$inboundSchema: z.ZodType<
   InputWizCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizCompression);
 /** @internal */
 export const InputWizCompression$outboundSchema: z.ZodType<
-  InputWizCompression,
+  string,
   z.ZodTypeDef,
   InputWizCompression
-> = z.union([
-  z.nativeEnum(InputWizCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizCompression);
 
 /** @internal */
 export const InputWizPqControls$inboundSchema: z.ZodType<
@@ -536,20 +518,13 @@ export const InputWizLogLevel$inboundSchema: z.ZodType<
   InputWizLogLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizLogLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizLogLevel);
 /** @internal */
 export const InputWizLogLevel$outboundSchema: z.ZodType<
-  InputWizLogLevel,
+  string,
   z.ZodTypeDef,
   InputWizLogLevel
-> = z.union([
-  z.nativeEnum(InputWizLogLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizLogLevel);
 
 /** @internal */
 export const InputWizContentConfig$inboundSchema: z.ZodType<
@@ -681,20 +656,13 @@ export const InputWizRetryType$inboundSchema: z.ZodType<
   InputWizRetryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizRetryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizRetryType);
 /** @internal */
 export const InputWizRetryType$outboundSchema: z.ZodType<
-  InputWizRetryType,
+  string,
   z.ZodTypeDef,
   InputWizRetryType
-> = z.union([
-  z.nativeEnum(InputWizRetryType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizRetryType);
 
 /** @internal */
 export const InputWizRetryRules$inboundSchema: z.ZodType<
@@ -761,20 +729,13 @@ export const InputWizAuthenticationMethod$inboundSchema: z.ZodType<
   InputWizAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizAuthenticationMethod);
 /** @internal */
 export const InputWizAuthenticationMethod$outboundSchema: z.ZodType<
-  InputWizAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputWizAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputWizAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizAuthenticationMethod);
 
 /** @internal */
 export const InputWiz$inboundSchema: z.ZodType<

package/src/models/inputwizwebhook.ts

@@ -4,12 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -353,40 +349,26 @@ export const InputWizWebhookMode$inboundSchema: z.ZodType<
   InputWizWebhookMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookMode);
 /** @internal */
 export const InputWizWebhookMode$outboundSchema: z.ZodType<
-  InputWizWebhookMode,
+  string,
   z.ZodTypeDef,
   InputWizWebhookMode
-> = z.union([
-  z.nativeEnum(InputWizWebhookMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookMode);
 
 /** @internal */
 export const InputWizWebhookCompression$inboundSchema: z.ZodType<
   InputWizWebhookCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookCompression);
 /** @internal */
 export const InputWizWebhookCompression$outboundSchema: z.ZodType<
-  InputWizWebhookCompression,
+  string,
   z.ZodTypeDef,
   InputWizWebhookCompression
-> = z.union([
-  z.nativeEnum(InputWizWebhookCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookCompression);
 
 /** @internal */
 export const InputWizWebhookPqControls$inboundSchema: z.ZodType<
@@ -486,40 +468,26 @@ export const InputWizWebhookMinimumTLSVersion$inboundSchema: z.ZodType<
   InputWizWebhookMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookMinimumTLSVersion);
 /** @internal */
 export const InputWizWebhookMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputWizWebhookMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputWizWebhookMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputWizWebhookMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookMinimumTLSVersion);
 
 /** @internal */
 export const InputWizWebhookMaximumTLSVersion$inboundSchema: z.ZodType<
   InputWizWebhookMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWizWebhookMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWizWebhookMaximumTLSVersion);
 /** @internal */
 export const InputWizWebhookMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputWizWebhookMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputWizWebhookMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputWizWebhookMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWizWebhookMaximumTLSVersion);
 
 /** @internal */
 export const InputWizWebhookTLSSettingsServerSide$inboundSchema: z.ZodType<

package/src/models/inputzscalerhec.ts

@@ -4,12 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import {
-  catchUnrecognizedEnum,
-  ClosedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -381,40 +377,26 @@ export const InputZscalerHecMode$inboundSchema: z.ZodType<
   InputZscalerHecMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecMode);
 /** @internal */
 export const InputZscalerHecMode$outboundSchema: z.ZodType<
-  InputZscalerHecMode,
+  string,
   z.ZodTypeDef,
   InputZscalerHecMode
-> = z.union([
-  z.nativeEnum(InputZscalerHecMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecMode);
 
 /** @internal */
 export const InputZscalerHecCompression$inboundSchema: z.ZodType<
   InputZscalerHecCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecCompression);
 /** @internal */
 export const InputZscalerHecCompression$outboundSchema: z.ZodType<
-  InputZscalerHecCompression,
+  string,
   z.ZodTypeDef,
   InputZscalerHecCompression
-> = z.union([
-  z.nativeEnum(InputZscalerHecCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecCompression);
 
 /** @internal */
 export const InputZscalerHecPqControls$inboundSchema: z.ZodType<
@@ -514,20 +496,13 @@ export const InputZscalerHecAuthenticationMethod$inboundSchema: z.ZodType<
   InputZscalerHecAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecAuthenticationMethod);
 /** @internal */
 export const InputZscalerHecAuthenticationMethod$outboundSchema: z.ZodType<
-  InputZscalerHecAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputZscalerHecAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputZscalerHecAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecAuthenticationMethod);
 
 /** @internal */
 export const InputZscalerHecAuthTokenMetadatum$inboundSchema: z.ZodType<
@@ -641,40 +616,26 @@ export const InputZscalerHecMinimumTLSVersion$inboundSchema: z.ZodType<
   InputZscalerHecMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecMinimumTLSVersion);
 /** @internal */
 export const InputZscalerHecMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputZscalerHecMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputZscalerHecMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputZscalerHecMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecMinimumTLSVersion);
 
 /** @internal */
 export const InputZscalerHecMaximumTLSVersion$inboundSchema: z.ZodType<
   InputZscalerHecMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputZscalerHecMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputZscalerHecMaximumTLSVersion);
 /** @internal */
 export const InputZscalerHecMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputZscalerHecMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputZscalerHecMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputZscalerHecMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputZscalerHecMaximumTLSVersion);
 
 /** @internal */
 export const InputZscalerHecTLSSettingsServerSide$inboundSchema: z.ZodType<

package/src/models/jobstatus.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";
 
@@ -37,11 +38,8 @@ export type JobStatus = {
 };
 
 /** @internal */
-export const State$inboundSchema: z.ZodType<State, z.ZodTypeDef, unknown> = z
-  .union([
-    z.nativeEnum(State),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+export const State$inboundSchema: z.ZodType<State, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchemaInt(State);
 
 /** @internal */
 export const JobStatus$inboundSchema: z.ZodType<

package/src/models/lakehouseconnectiontype.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 LakehouseConnectionType = {
   Cache: "cache",
@@ -20,17 +17,10 @@ export const LakehouseConnectionType$inboundSchema: z.ZodType<
   LakehouseConnectionType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(LakehouseConnectionType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(LakehouseConnectionType);
 /** @internal */
 export const LakehouseConnectionType$outboundSchema: z.ZodType<
-  LakehouseConnectionType,
+  string,
   z.ZodTypeDef,
   LakehouseConnectionType
-> = z.union([
-  z.nativeEnum(LakehouseConnectionType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(LakehouseConnectionType);

package/src/models/masterworkerentry.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";
 import {
@@ -53,11 +54,7 @@ export const MasterWorkerEntryType$inboundSchema: z.ZodType<
   MasterWorkerEntryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MasterWorkerEntryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MasterWorkerEntryType);
 
 /** @internal */
 export const MasterWorkerEntryWorkers$inboundSchema: z.ZodType<

package/src/models/nodeactiveupgradestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeActiveUpgradeStatus = {
   Zero: 0,
@@ -17,8 +18,4 @@ export const NodeActiveUpgradeStatus$inboundSchema: z.ZodType<
   NodeActiveUpgradeStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeActiveUpgradeStatus),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeActiveUpgradeStatus);

package/src/models/nodefailedupgradestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeFailedUpgradeStatus = {
   Zero: 0,
@@ -16,8 +17,4 @@ export const NodeFailedUpgradeStatus$inboundSchema: z.ZodType<
   NodeFailedUpgradeStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeFailedUpgradeStatus),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeFailedUpgradeStatus);

package/src/models/nodeskippedupgradestatus.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeSkippedUpgradeStatus = {
   Zero: 0,
@@ -20,8 +21,4 @@ export const NodeSkippedUpgradeStatus$inboundSchema: z.ZodType<
   NodeSkippedUpgradeStatus,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeSkippedUpgradeStatus),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeSkippedUpgradeStatus);

package/src/models/nodeupgradestate.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { catchUnrecognizedEnum, OpenEnum } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const NodeUpgradeState = {
   Zero: 0,
@@ -18,8 +19,4 @@ export const NodeUpgradeState$inboundSchema: z.ZodType<
   NodeUpgradeState,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(NodeUpgradeState),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(NodeUpgradeState);