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

package/src/models/inputtcp.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";
 
@@ -336,40 +332,26 @@ export const InputTcpMode$inboundSchema: z.ZodType<
   InputTcpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpMode);
 /** @internal */
 export const InputTcpMode$outboundSchema: z.ZodType<
-  InputTcpMode,
+  string,
   z.ZodTypeDef,
   InputTcpMode
-> = z.union([
-  z.nativeEnum(InputTcpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpMode);
 
 /** @internal */
 export const InputTcpCompression$inboundSchema: z.ZodType<
   InputTcpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpCompression);
 /** @internal */
 export const InputTcpCompression$outboundSchema: z.ZodType<
-  InputTcpCompression,
+  string,
   z.ZodTypeDef,
   InputTcpCompression
-> = z.union([
-  z.nativeEnum(InputTcpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpCompression);
 
 /** @internal */
 export const InputTcpPqControls$inboundSchema: z.ZodType<
@@ -465,40 +447,26 @@ export const InputTcpMinimumTLSVersion$inboundSchema: z.ZodType<
   InputTcpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpMinimumTLSVersion);
 /** @internal */
 export const InputTcpMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputTcpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputTcpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputTcpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpMinimumTLSVersion);
 
 /** @internal */
 export const InputTcpMaximumTLSVersion$inboundSchema: z.ZodType<
   InputTcpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpMaximumTLSVersion);
 /** @internal */
 export const InputTcpMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputTcpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputTcpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputTcpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpMaximumTLSVersion);
 
 /** @internal */
 export const InputTcpTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -663,20 +631,13 @@ export const InputTcpAuthenticationMethod$inboundSchema: z.ZodType<
   InputTcpAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpAuthenticationMethod);
 /** @internal */
 export const InputTcpAuthenticationMethod$outboundSchema: z.ZodType<
-  InputTcpAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputTcpAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputTcpAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpAuthenticationMethod);
 
 /** @internal */
 export const InputTcp$inboundSchema: z.ZodType<

package/src/models/inputtcpjson.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";
 
@@ -317,40 +313,26 @@ export const InputTcpjsonMode$inboundSchema: z.ZodType<
   InputTcpjsonMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpjsonMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpjsonMode);
 /** @internal */
 export const InputTcpjsonMode$outboundSchema: z.ZodType<
-  InputTcpjsonMode,
+  string,
   z.ZodTypeDef,
   InputTcpjsonMode
-> = z.union([
-  z.nativeEnum(InputTcpjsonMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpjsonMode);
 
 /** @internal */
 export const InputTcpjsonCompression$inboundSchema: z.ZodType<
   InputTcpjsonCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpjsonCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpjsonCompression);
 /** @internal */
 export const InputTcpjsonCompression$outboundSchema: z.ZodType<
-  InputTcpjsonCompression,
+  string,
   z.ZodTypeDef,
   InputTcpjsonCompression
-> = z.union([
-  z.nativeEnum(InputTcpjsonCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpjsonCompression);
 
 /** @internal */
 export const InputTcpjsonPqControls$inboundSchema: z.ZodType<
@@ -446,40 +428,26 @@ export const InputTcpjsonMinimumTLSVersion$inboundSchema: z.ZodType<
   InputTcpjsonMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpjsonMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpjsonMinimumTLSVersion);
 /** @internal */
 export const InputTcpjsonMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputTcpjsonMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputTcpjsonMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputTcpjsonMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpjsonMinimumTLSVersion);
 
 /** @internal */
 export const InputTcpjsonMaximumTLSVersion$inboundSchema: z.ZodType<
   InputTcpjsonMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpjsonMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpjsonMaximumTLSVersion);
 /** @internal */
 export const InputTcpjsonMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputTcpjsonMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputTcpjsonMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputTcpjsonMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpjsonMaximumTLSVersion);
 
 /** @internal */
 export const InputTcpjsonTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -599,20 +567,13 @@ export const InputTcpjsonAuthenticationMethod$inboundSchema: z.ZodType<
   InputTcpjsonAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpjsonAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpjsonAuthenticationMethod);
 /** @internal */
 export const InputTcpjsonAuthenticationMethod$outboundSchema: z.ZodType<
-  InputTcpjsonAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputTcpjsonAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputTcpjsonAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpjsonAuthenticationMethod);
 
 /** @internal */
 export const InputTcpjson$inboundSchema: z.ZodType<

package/src/models/inputwef.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";
 
@@ -445,40 +441,26 @@ export const InputWefMode$inboundSchema: z.ZodType<
   InputWefMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWefMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWefMode);
 /** @internal */
 export const InputWefMode$outboundSchema: z.ZodType<
-  InputWefMode,
+  string,
   z.ZodTypeDef,
   InputWefMode
-> = z.union([
-  z.nativeEnum(InputWefMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWefMode);
 
 /** @internal */
 export const InputWefCompression$inboundSchema: z.ZodType<
   InputWefCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWefCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWefCompression);
 /** @internal */
 export const InputWefCompression$outboundSchema: z.ZodType<
-  InputWefCompression,
+  string,
   z.ZodTypeDef,
   InputWefCompression
-> = z.union([
-  z.nativeEnum(InputWefCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWefCompression);
 
 /** @internal */
 export const InputWefPqControls$inboundSchema: z.ZodType<
@@ -574,60 +556,39 @@ export const InputWefAuthenticationMethod$inboundSchema: z.ZodType<
   InputWefAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWefAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWefAuthenticationMethod);
 /** @internal */
 export const InputWefAuthenticationMethod$outboundSchema: z.ZodType<
-  InputWefAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputWefAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputWefAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWefAuthenticationMethod);
 
 /** @internal */
 export const InputWefMinimumTLSVersion$inboundSchema: z.ZodType<
   InputWefMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWefMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWefMinimumTLSVersion);
 /** @internal */
 export const InputWefMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputWefMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputWefMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputWefMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWefMinimumTLSVersion);
 
 /** @internal */
 export const InputWefMaximumTLSVersion$inboundSchema: z.ZodType<
   InputWefMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWefMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWefMaximumTLSVersion);
 /** @internal */
 export const InputWefMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputWefMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputWefMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputWefMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWefMaximumTLSVersion);
 
 /** @internal */
 export const MTLSSettings$inboundSchema: z.ZodType<
@@ -711,40 +672,26 @@ export const InputWefFormat$inboundSchema: z.ZodType<
   InputWefFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWefFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWefFormat);
 /** @internal */
 export const InputWefFormat$outboundSchema: z.ZodType<
-  InputWefFormat,
+  string,
   z.ZodTypeDef,
   InputWefFormat
-> = z.union([
-  z.nativeEnum(InputWefFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWefFormat);
 
 /** @internal */
 export const QueryBuilderMode$inboundSchema: z.ZodType<
   QueryBuilderMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(QueryBuilderMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(QueryBuilderMode);
 /** @internal */
 export const QueryBuilderMode$outboundSchema: z.ZodType<
-  QueryBuilderMode,
+  string,
   z.ZodTypeDef,
   QueryBuilderMode
-> = z.union([
-  z.nativeEnum(QueryBuilderMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(QueryBuilderMode);
 
 /** @internal */
 export const SubscriptionMetadatum$inboundSchema: z.ZodType<

package/src/models/inputwindowsmetrics.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";
 
@@ -527,40 +523,26 @@ export const InputWindowsMetricsPqMode$inboundSchema: z.ZodType<
   InputWindowsMetricsPqMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsPqMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsPqMode);
 /** @internal */
 export const InputWindowsMetricsPqMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsPqMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsPqMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsPqMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsPqMode);
 
 /** @internal */
 export const InputWindowsMetricsCompression$inboundSchema: z.ZodType<
   InputWindowsMetricsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsCompression);
 /** @internal */
 export const InputWindowsMetricsCompression$outboundSchema: z.ZodType<
-  InputWindowsMetricsCompression,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsCompression
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsCompression);
 
 /** @internal */
 export const InputWindowsMetricsPqControls$inboundSchema: z.ZodType<
@@ -664,40 +646,26 @@ export const InputWindowsMetricsHostMode$inboundSchema: z.ZodType<
   InputWindowsMetricsHostMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsHostMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsHostMode);
 /** @internal */
 export const InputWindowsMetricsHostMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsHostMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsHostMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsHostMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsHostMode);
 
 /** @internal */
 export const InputWindowsMetricsSystemMode$inboundSchema: z.ZodType<
   InputWindowsMetricsSystemMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsSystemMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsSystemMode);
 /** @internal */
 export const InputWindowsMetricsSystemMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsSystemMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsSystemMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsSystemMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsSystemMode);
 
 /** @internal */
 export const InputWindowsMetricsSystem$inboundSchema: z.ZodType<
@@ -746,20 +714,13 @@ export const InputWindowsMetricsCpuMode$inboundSchema: z.ZodType<
   InputWindowsMetricsCpuMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsCpuMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsCpuMode);
 /** @internal */
 export const InputWindowsMetricsCpuMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsCpuMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsCpuMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsCpuMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsCpuMode);
 
 /** @internal */
 export const InputWindowsMetricsCpu$inboundSchema: z.ZodType<
@@ -814,20 +775,13 @@ export const InputWindowsMetricsMemoryMode$inboundSchema: z.ZodType<
   InputWindowsMetricsMemoryMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsMemoryMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsMemoryMode);
 /** @internal */
 export const InputWindowsMetricsMemoryMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsMemoryMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsMemoryMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsMemoryMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsMemoryMode);
 
 /** @internal */
 export const InputWindowsMetricsMemory$inboundSchema: z.ZodType<
@@ -876,20 +830,13 @@ export const InputWindowsMetricsNetworkMode$inboundSchema: z.ZodType<
   InputWindowsMetricsNetworkMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsNetworkMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsNetworkMode);
 /** @internal */
 export const InputWindowsMetricsNetworkMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsNetworkMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsNetworkMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsNetworkMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsNetworkMode);
 
 /** @internal */
 export const InputWindowsMetricsNetwork$inboundSchema: z.ZodType<
@@ -947,20 +894,13 @@ export const InputWindowsMetricsDiskMode$inboundSchema: z.ZodType<
   InputWindowsMetricsDiskMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsDiskMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsDiskMode);
 /** @internal */
 export const InputWindowsMetricsDiskMode$outboundSchema: z.ZodType<
-  InputWindowsMetricsDiskMode,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsDiskMode
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsDiskMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsDiskMode);
 
 /** @internal */
 export const InputWindowsMetricsDisk$inboundSchema: z.ZodType<
@@ -1236,20 +1176,13 @@ export const InputWindowsMetricsDataCompressionFormat$inboundSchema: z.ZodType<
   InputWindowsMetricsDataCompressionFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputWindowsMetricsDataCompressionFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputWindowsMetricsDataCompressionFormat);
 /** @internal */
 export const InputWindowsMetricsDataCompressionFormat$outboundSchema: z.ZodType<
-  InputWindowsMetricsDataCompressionFormat,
+  string,
   z.ZodTypeDef,
   InputWindowsMetricsDataCompressionFormat
-> = z.union([
-  z.nativeEnum(InputWindowsMetricsDataCompressionFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputWindowsMetricsDataCompressionFormat);
 
 /** @internal */
 export const InputWindowsMetricsPersistence$inboundSchema: z.ZodType<