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

package/src/models/inputsqs.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";
 
@@ -328,40 +324,26 @@ export const InputSqsMode$inboundSchema: z.ZodType<
   InputSqsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsMode);
 /** @internal */
 export const InputSqsMode$outboundSchema: z.ZodType<
-  InputSqsMode,
+  string,
   z.ZodTypeDef,
   InputSqsMode
-> = z.union([
-  z.nativeEnum(InputSqsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsMode);
 
 /** @internal */
 export const InputSqsCompression$inboundSchema: z.ZodType<
   InputSqsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsCompression);
 /** @internal */
 export const InputSqsCompression$outboundSchema: z.ZodType<
-  InputSqsCompression,
+  string,
   z.ZodTypeDef,
   InputSqsCompression
-> = z.union([
-  z.nativeEnum(InputSqsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsCompression);
 
 /** @internal */
 export const InputSqsPqControls$inboundSchema: z.ZodType<
@@ -457,60 +439,39 @@ export const InputSqsQueueType$inboundSchema: z.ZodType<
   InputSqsQueueType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsQueueType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsQueueType);
 /** @internal */
 export const InputSqsQueueType$outboundSchema: z.ZodType<
-  InputSqsQueueType,
+  string,
   z.ZodTypeDef,
   InputSqsQueueType
-> = z.union([
-  z.nativeEnum(InputSqsQueueType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsQueueType);
 
 /** @internal */
 export const InputSqsAuthenticationMethod$inboundSchema: z.ZodType<
   InputSqsAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsAuthenticationMethod);
 /** @internal */
 export const InputSqsAuthenticationMethod$outboundSchema: z.ZodType<
-  InputSqsAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputSqsAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputSqsAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsAuthenticationMethod);
 
 /** @internal */
 export const InputSqsSignatureVersion$inboundSchema: z.ZodType<
   InputSqsSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsSignatureVersion);
 /** @internal */
 export const InputSqsSignatureVersion$outboundSchema: z.ZodType<
-  InputSqsSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputSqsSignatureVersion
-> = z.union([
-  z.nativeEnum(InputSqsSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsSignatureVersion);
 
 /** @internal */
 export const InputSqsMetadatum$inboundSchema: z.ZodType<

package/src/models/inputsyslog.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";
 
@@ -603,40 +599,26 @@ export const InputSyslogMode2$inboundSchema: z.ZodType<
   InputSyslogMode2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMode2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMode2);
 /** @internal */
 export const InputSyslogMode2$outboundSchema: z.ZodType<
-  InputSyslogMode2,
+  string,
   z.ZodTypeDef,
   InputSyslogMode2
-> = z.union([
-  z.nativeEnum(InputSyslogMode2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMode2);
 
 /** @internal */
 export const InputSyslogCompression2$inboundSchema: z.ZodType<
   InputSyslogCompression2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogCompression2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogCompression2);
 /** @internal */
 export const InputSyslogCompression2$outboundSchema: z.ZodType<
-  InputSyslogCompression2,
+  string,
   z.ZodTypeDef,
   InputSyslogCompression2
-> = z.union([
-  z.nativeEnum(InputSyslogCompression2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogCompression2);
 
 /** @internal */
 export const InputSyslogPqControls2$inboundSchema: z.ZodType<
@@ -732,40 +714,26 @@ export const InputSyslogMinimumTLSVersion2$inboundSchema: z.ZodType<
   InputSyslogMinimumTLSVersion2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMinimumTLSVersion2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMinimumTLSVersion2);
 /** @internal */
 export const InputSyslogMinimumTLSVersion2$outboundSchema: z.ZodType<
-  InputSyslogMinimumTLSVersion2,
+  string,
   z.ZodTypeDef,
   InputSyslogMinimumTLSVersion2
-> = z.union([
-  z.nativeEnum(InputSyslogMinimumTLSVersion2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMinimumTLSVersion2);
 
 /** @internal */
 export const InputSyslogMaximumTLSVersion2$inboundSchema: z.ZodType<
   InputSyslogMaximumTLSVersion2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMaximumTLSVersion2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMaximumTLSVersion2);
 /** @internal */
 export const InputSyslogMaximumTLSVersion2$outboundSchema: z.ZodType<
-  InputSyslogMaximumTLSVersion2,
+  string,
   z.ZodTypeDef,
   InputSyslogMaximumTLSVersion2
-> = z.union([
-  z.nativeEnum(InputSyslogMaximumTLSVersion2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMaximumTLSVersion2);
 
 /** @internal */
 export const InputSyslogTLSSettingsServerSide2$inboundSchema: z.ZodType<
@@ -1076,40 +1044,26 @@ export const InputSyslogMode1$inboundSchema: z.ZodType<
   InputSyslogMode1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMode1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMode1);
 /** @internal */
 export const InputSyslogMode1$outboundSchema: z.ZodType<
-  InputSyslogMode1,
+  string,
   z.ZodTypeDef,
   InputSyslogMode1
-> = z.union([
-  z.nativeEnum(InputSyslogMode1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMode1);
 
 /** @internal */
 export const InputSyslogCompression1$inboundSchema: z.ZodType<
   InputSyslogCompression1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogCompression1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogCompression1);
 /** @internal */
 export const InputSyslogCompression1$outboundSchema: z.ZodType<
-  InputSyslogCompression1,
+  string,
   z.ZodTypeDef,
   InputSyslogCompression1
-> = z.union([
-  z.nativeEnum(InputSyslogCompression1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogCompression1);
 
 /** @internal */
 export const InputSyslogPqControls1$inboundSchema: z.ZodType<
@@ -1205,40 +1159,26 @@ export const InputSyslogMinimumTLSVersion1$inboundSchema: z.ZodType<
   InputSyslogMinimumTLSVersion1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMinimumTLSVersion1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMinimumTLSVersion1);
 /** @internal */
 export const InputSyslogMinimumTLSVersion1$outboundSchema: z.ZodType<
-  InputSyslogMinimumTLSVersion1,
+  string,
   z.ZodTypeDef,
   InputSyslogMinimumTLSVersion1
-> = z.union([
-  z.nativeEnum(InputSyslogMinimumTLSVersion1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMinimumTLSVersion1);
 
 /** @internal */
 export const InputSyslogMaximumTLSVersion1$inboundSchema: z.ZodType<
   InputSyslogMaximumTLSVersion1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMaximumTLSVersion1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMaximumTLSVersion1);
 /** @internal */
 export const InputSyslogMaximumTLSVersion1$outboundSchema: z.ZodType<
-  InputSyslogMaximumTLSVersion1,
+  string,
   z.ZodTypeDef,
   InputSyslogMaximumTLSVersion1
-> = z.union([
-  z.nativeEnum(InputSyslogMaximumTLSVersion1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMaximumTLSVersion1);
 
 /** @internal */
 export const InputSyslogTLSSettingsServerSide1$inboundSchema: z.ZodType<

package/src/models/inputsystemmetrics.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";
 
@@ -595,40 +591,26 @@ export const InputSystemMetricsPqMode$inboundSchema: z.ZodType<
   InputSystemMetricsPqMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsPqMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsPqMode);
 /** @internal */
 export const InputSystemMetricsPqMode$outboundSchema: z.ZodType<
-  InputSystemMetricsPqMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsPqMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsPqMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsPqMode);
 
 /** @internal */
 export const InputSystemMetricsCompression$inboundSchema: z.ZodType<
   InputSystemMetricsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsCompression);
 /** @internal */
 export const InputSystemMetricsCompression$outboundSchema: z.ZodType<
-  InputSystemMetricsCompression,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsCompression
-> = z.union([
-  z.nativeEnum(InputSystemMetricsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsCompression);
 
 /** @internal */
 export const InputSystemMetricsPqControls$inboundSchema: z.ZodType<
@@ -732,40 +714,26 @@ export const InputSystemMetricsHostMode$inboundSchema: z.ZodType<
   InputSystemMetricsHostMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsHostMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsHostMode);
 /** @internal */
 export const InputSystemMetricsHostMode$outboundSchema: z.ZodType<
-  InputSystemMetricsHostMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsHostMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsHostMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsHostMode);
 
 /** @internal */
 export const InputSystemMetricsSystemMode$inboundSchema: z.ZodType<
   InputSystemMetricsSystemMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsSystemMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsSystemMode);
 /** @internal */
 export const InputSystemMetricsSystemMode$outboundSchema: z.ZodType<
-  InputSystemMetricsSystemMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsSystemMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsSystemMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsSystemMode);
 
 /** @internal */
 export const InputSystemMetricsSystem$inboundSchema: z.ZodType<
@@ -814,20 +782,13 @@ export const InputSystemMetricsCpuMode$inboundSchema: z.ZodType<
   InputSystemMetricsCpuMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsCpuMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsCpuMode);
 /** @internal */
 export const InputSystemMetricsCpuMode$outboundSchema: z.ZodType<
-  InputSystemMetricsCpuMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsCpuMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsCpuMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsCpuMode);
 
 /** @internal */
 export const InputSystemMetricsCpu$inboundSchema: z.ZodType<
@@ -882,20 +843,13 @@ export const InputSystemMetricsMemoryMode$inboundSchema: z.ZodType<
   InputSystemMetricsMemoryMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsMemoryMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsMemoryMode);
 /** @internal */
 export const InputSystemMetricsMemoryMode$outboundSchema: z.ZodType<
-  InputSystemMetricsMemoryMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsMemoryMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsMemoryMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsMemoryMode);
 
 /** @internal */
 export const InputSystemMetricsMemory$inboundSchema: z.ZodType<
@@ -944,20 +898,13 @@ export const InputSystemMetricsNetworkMode$inboundSchema: z.ZodType<
   InputSystemMetricsNetworkMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsNetworkMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsNetworkMode);
 /** @internal */
 export const InputSystemMetricsNetworkMode$outboundSchema: z.ZodType<
-  InputSystemMetricsNetworkMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsNetworkMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsNetworkMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsNetworkMode);
 
 /** @internal */
 export const InputSystemMetricsNetwork$inboundSchema: z.ZodType<
@@ -1015,20 +962,13 @@ export const InputSystemMetricsDiskMode$inboundSchema: z.ZodType<
   InputSystemMetricsDiskMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsDiskMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsDiskMode);
 /** @internal */
 export const InputSystemMetricsDiskMode$outboundSchema: z.ZodType<
-  InputSystemMetricsDiskMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsDiskMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsDiskMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsDiskMode);
 
 /** @internal */
 export const InputSystemMetricsDisk$inboundSchema: z.ZodType<
@@ -1269,20 +1209,13 @@ export const ContainerMode$inboundSchema: z.ZodType<
   ContainerMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ContainerMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ContainerMode);
 /** @internal */
 export const ContainerMode$outboundSchema: z.ZodType<
-  ContainerMode,
+  string,
   z.ZodTypeDef,
   ContainerMode
-> = z.union([
-  z.nativeEnum(ContainerMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ContainerMode);
 
 /** @internal */
 export const InputSystemMetricsFilter$inboundSchema: z.ZodType<
@@ -1427,20 +1360,13 @@ export const InputSystemMetricsDataCompressionFormat$inboundSchema: z.ZodType<
   InputSystemMetricsDataCompressionFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsDataCompressionFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsDataCompressionFormat);
 /** @internal */
 export const InputSystemMetricsDataCompressionFormat$outboundSchema: z.ZodType<
-  InputSystemMetricsDataCompressionFormat,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsDataCompressionFormat
-> = z.union([
-  z.nativeEnum(InputSystemMetricsDataCompressionFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsDataCompressionFormat);
 
 /** @internal */
 export const InputSystemMetricsPersistence$inboundSchema: z.ZodType<

package/src/models/inputsystemstate.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";
 
@@ -364,40 +360,26 @@ export const InputSystemStateMode$inboundSchema: z.ZodType<
   InputSystemStateMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemStateMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemStateMode);
 /** @internal */
 export const InputSystemStateMode$outboundSchema: z.ZodType<
-  InputSystemStateMode,
+  string,
   z.ZodTypeDef,
   InputSystemStateMode
-> = z.union([
-  z.nativeEnum(InputSystemStateMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemStateMode);
 
 /** @internal */
 export const InputSystemStateCompression$inboundSchema: z.ZodType<
   InputSystemStateCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemStateCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemStateCompression);
 /** @internal */
 export const InputSystemStateCompression$outboundSchema: z.ZodType<
-  InputSystemStateCompression,
+  string,
   z.ZodTypeDef,
   InputSystemStateCompression
-> = z.union([
-  z.nativeEnum(InputSystemStateCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemStateCompression);
 
 /** @internal */
 export const InputSystemStatePqControls$inboundSchema: z.ZodType<
@@ -992,20 +974,13 @@ export const InputSystemStateDataCompressionFormat$inboundSchema: z.ZodType<
   InputSystemStateDataCompressionFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemStateDataCompressionFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemStateDataCompressionFormat);
 /** @internal */
 export const InputSystemStateDataCompressionFormat$outboundSchema: z.ZodType<
-  InputSystemStateDataCompressionFormat,
+  string,
   z.ZodTypeDef,
   InputSystemStateDataCompressionFormat
-> = z.union([
-  z.nativeEnum(InputSystemStateDataCompressionFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemStateDataCompressionFormat);
 
 /** @internal */
 export const InputSystemStatePersistence$inboundSchema: z.ZodType<