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

package/src/models/inputprometheus.ts

@@ -5,12 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 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";
 
@@ -458,40 +454,26 @@ export const InputPrometheusMode$inboundSchema: z.ZodType<
   InputPrometheusMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusMode);
 /** @internal */
 export const InputPrometheusMode$outboundSchema: z.ZodType<
-  InputPrometheusMode,
+  string,
   z.ZodTypeDef,
   InputPrometheusMode
-> = z.union([
-  z.nativeEnum(InputPrometheusMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusMode);
 
 /** @internal */
 export const InputPrometheusCompression$inboundSchema: z.ZodType<
   InputPrometheusCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusCompression);
 /** @internal */
 export const InputPrometheusCompression$outboundSchema: z.ZodType<
-  InputPrometheusCompression,
+  string,
   z.ZodTypeDef,
   InputPrometheusCompression
-> = z.union([
-  z.nativeEnum(InputPrometheusCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusCompression);
 
 /** @internal */
 export const InputPrometheusPqControls$inboundSchema: z.ZodType<
@@ -591,40 +573,26 @@ export const InputPrometheusDiscoveryType$inboundSchema: z.ZodType<
   InputPrometheusDiscoveryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusDiscoveryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusDiscoveryType);
 /** @internal */
 export const InputPrometheusDiscoveryType$outboundSchema: z.ZodType<
-  InputPrometheusDiscoveryType,
+  string,
   z.ZodTypeDef,
   InputPrometheusDiscoveryType
-> = z.union([
-  z.nativeEnum(InputPrometheusDiscoveryType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusDiscoveryType);
 
 /** @internal */
 export const InputPrometheusLogLevel$inboundSchema: z.ZodType<
   InputPrometheusLogLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusLogLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusLogLevel);
 /** @internal */
 export const InputPrometheusLogLevel$outboundSchema: z.ZodType<
-  InputPrometheusLogLevel,
+  string,
   z.ZodTypeDef,
   InputPrometheusLogLevel
-> = z.union([
-  z.nativeEnum(InputPrometheusLogLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusLogLevel);
 
 /** @internal */
 export const InputPrometheusMetadatum$inboundSchema: z.ZodType<
@@ -674,61 +642,37 @@ export const InputPrometheusAuthTypeAuthenticationMethod$inboundSchema:
     InputPrometheusAuthTypeAuthenticationMethod,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputPrometheusAuthTypeAuthenticationMethod),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputPrometheusAuthTypeAuthenticationMethod);
 /** @internal */
 export const InputPrometheusAuthTypeAuthenticationMethod$outboundSchema:
-  z.ZodType<
-    InputPrometheusAuthTypeAuthenticationMethod,
-    z.ZodTypeDef,
-    InputPrometheusAuthTypeAuthenticationMethod
-  > = z.union([
-    z.nativeEnum(InputPrometheusAuthTypeAuthenticationMethod),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, InputPrometheusAuthTypeAuthenticationMethod> =
+    openEnums.outboundSchema(InputPrometheusAuthTypeAuthenticationMethod);
 
 /** @internal */
 export const InputPrometheusRecordType$inboundSchema: z.ZodType<
   InputPrometheusRecordType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRecordType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRecordType);
 /** @internal */
 export const InputPrometheusRecordType$outboundSchema: z.ZodType<
-  InputPrometheusRecordType,
+  string,
   z.ZodTypeDef,
   InputPrometheusRecordType
-> = z.union([
-  z.nativeEnum(InputPrometheusRecordType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRecordType);
 
 /** @internal */
 export const MetricsProtocol$inboundSchema: z.ZodType<
   MetricsProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MetricsProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MetricsProtocol);
 /** @internal */
 export const MetricsProtocol$outboundSchema: z.ZodType<
-  MetricsProtocol,
+  string,
   z.ZodTypeDef,
   MetricsProtocol
-> = z.union([
-  z.nativeEnum(MetricsProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(MetricsProtocol);
 
 /** @internal */
 export const InputPrometheusAwsAuthenticationMethodAuthenticationMethod$inboundSchema:
@@ -736,21 +680,18 @@ export const InputPrometheusAwsAuthenticationMethodAuthenticationMethod$inboundS
     InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputPrometheusAwsAuthenticationMethodAuthenticationMethod),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
+  );
 /** @internal */
 export const InputPrometheusAwsAuthenticationMethodAuthenticationMethod$outboundSchema:
   z.ZodType<
-    InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
+    string,
     z.ZodTypeDef,
     InputPrometheusAwsAuthenticationMethodAuthenticationMethod
-  > = z.union([
-    z.nativeEnum(InputPrometheusAwsAuthenticationMethodAuthenticationMethod),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
+  );
 
 /** @internal */
 export const InputPrometheusSearchFilter$inboundSchema: z.ZodType<
@@ -811,20 +752,13 @@ export const InputPrometheusSignatureVersion$inboundSchema: z.ZodType<
   InputPrometheusSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusSignatureVersion);
 /** @internal */
 export const InputPrometheusSignatureVersion$outboundSchema: z.ZodType<
-  InputPrometheusSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputPrometheusSignatureVersion
-> = z.union([
-  z.nativeEnum(InputPrometheusSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusSignatureVersion);
 
 /** @internal */
 export const InputPrometheus$inboundSchema: z.ZodType<

package/src/models/inputprometheusrw.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";
 
@@ -405,40 +401,26 @@ export const InputPrometheusRwMode$inboundSchema: z.ZodType<
   InputPrometheusRwMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwMode);
 /** @internal */
 export const InputPrometheusRwMode$outboundSchema: z.ZodType<
-  InputPrometheusRwMode,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwMode
-> = z.union([
-  z.nativeEnum(InputPrometheusRwMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwMode);
 
 /** @internal */
 export const InputPrometheusRwCompression$inboundSchema: z.ZodType<
   InputPrometheusRwCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwCompression);
 /** @internal */
 export const InputPrometheusRwCompression$outboundSchema: z.ZodType<
-  InputPrometheusRwCompression,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwCompression
-> = z.union([
-  z.nativeEnum(InputPrometheusRwCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwCompression);
 
 /** @internal */
 export const InputPrometheusRwPqControls$inboundSchema: z.ZodType<
@@ -542,40 +524,26 @@ export const InputPrometheusRwMinimumTLSVersion$inboundSchema: z.ZodType<
   InputPrometheusRwMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwMinimumTLSVersion);
 /** @internal */
 export const InputPrometheusRwMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputPrometheusRwMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputPrometheusRwMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwMinimumTLSVersion);
 
 /** @internal */
 export const InputPrometheusRwMaximumTLSVersion$inboundSchema: z.ZodType<
   InputPrometheusRwMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwMaximumTLSVersion);
 /** @internal */
 export const InputPrometheusRwMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputPrometheusRwMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputPrometheusRwMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwMaximumTLSVersion);
 
 /** @internal */
 export const InputPrometheusRwTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -655,20 +623,13 @@ export const InputPrometheusRwAuthenticationType$inboundSchema: z.ZodType<
   InputPrometheusRwAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwAuthenticationType);
 /** @internal */
 export const InputPrometheusRwAuthenticationType$outboundSchema: z.ZodType<
-  InputPrometheusRwAuthenticationType,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwAuthenticationType
-> = z.union([
-  z.nativeEnum(InputPrometheusRwAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwAuthenticationType);
 
 /** @internal */
 export const InputPrometheusRwMetadatum$inboundSchema: z.ZodType<

package/src/models/inputrawudp.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";
 
@@ -224,40 +220,26 @@ export const InputRawUdpMode$inboundSchema: z.ZodType<
   InputRawUdpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputRawUdpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputRawUdpMode);
 /** @internal */
 export const InputRawUdpMode$outboundSchema: z.ZodType<
-  InputRawUdpMode,
+  string,
   z.ZodTypeDef,
   InputRawUdpMode
-> = z.union([
-  z.nativeEnum(InputRawUdpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputRawUdpMode);
 
 /** @internal */
 export const InputRawUdpCompression$inboundSchema: z.ZodType<
   InputRawUdpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputRawUdpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputRawUdpCompression);
 /** @internal */
 export const InputRawUdpCompression$outboundSchema: z.ZodType<
-  InputRawUdpCompression,
+  string,
   z.ZodTypeDef,
   InputRawUdpCompression
-> = z.union([
-  z.nativeEnum(InputRawUdpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputRawUdpCompression);
 
 /** @internal */
 export const InputRawUdpPqControls$inboundSchema: z.ZodType<

package/src/models/inputs3.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";
 
@@ -377,40 +373,26 @@ export const InputS3Mode$inboundSchema: z.ZodType<
   InputS3Mode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3Mode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3Mode);
 /** @internal */
 export const InputS3Mode$outboundSchema: z.ZodType<
-  InputS3Mode,
+  string,
   z.ZodTypeDef,
   InputS3Mode
-> = z.union([
-  z.nativeEnum(InputS3Mode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3Mode);
 
 /** @internal */
 export const InputS3Compression$inboundSchema: z.ZodType<
   InputS3Compression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3Compression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3Compression);
 /** @internal */
 export const InputS3Compression$outboundSchema: z.ZodType<
-  InputS3Compression,
+  string,
   z.ZodTypeDef,
   InputS3Compression
-> = z.union([
-  z.nativeEnum(InputS3Compression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3Compression);
 
 /** @internal */
 export const InputS3PqControls$inboundSchema: z.ZodType<
@@ -506,40 +488,26 @@ export const InputS3AuthenticationMethod$inboundSchema: z.ZodType<
   InputS3AuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3AuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3AuthenticationMethod);
 /** @internal */
 export const InputS3AuthenticationMethod$outboundSchema: z.ZodType<
-  InputS3AuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputS3AuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputS3AuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3AuthenticationMethod);
 
 /** @internal */
 export const InputS3SignatureVersion$inboundSchema: z.ZodType<
   InputS3SignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3SignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3SignatureVersion);
 /** @internal */
 export const InputS3SignatureVersion$outboundSchema: z.ZodType<
-  InputS3SignatureVersion,
+  string,
   z.ZodTypeDef,
   InputS3SignatureVersion
-> = z.union([
-  z.nativeEnum(InputS3SignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3SignatureVersion);
 
 /** @internal */
 export const InputS3Preprocess$inboundSchema: z.ZodType<

package/src/models/inputs3inventory.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";
 
@@ -396,40 +392,26 @@ export const InputS3InventoryMode$inboundSchema: z.ZodType<
   InputS3InventoryMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3InventoryMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3InventoryMode);
 /** @internal */
 export const InputS3InventoryMode$outboundSchema: z.ZodType<
-  InputS3InventoryMode,
+  string,
   z.ZodTypeDef,
   InputS3InventoryMode
-> = z.union([
-  z.nativeEnum(InputS3InventoryMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3InventoryMode);
 
 /** @internal */
 export const InputS3InventoryCompression$inboundSchema: z.ZodType<
   InputS3InventoryCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3InventoryCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3InventoryCompression);
 /** @internal */
 export const InputS3InventoryCompression$outboundSchema: z.ZodType<
-  InputS3InventoryCompression,
+  string,
   z.ZodTypeDef,
   InputS3InventoryCompression
-> = z.union([
-  z.nativeEnum(InputS3InventoryCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3InventoryCompression);
 
 /** @internal */
 export const InputS3InventoryPqControls$inboundSchema: z.ZodType<
@@ -530,40 +512,26 @@ export const InputS3InventoryAuthenticationMethod$inboundSchema: z.ZodType<
   InputS3InventoryAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3InventoryAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3InventoryAuthenticationMethod);
 /** @internal */
 export const InputS3InventoryAuthenticationMethod$outboundSchema: z.ZodType<
-  InputS3InventoryAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputS3InventoryAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputS3InventoryAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3InventoryAuthenticationMethod);
 
 /** @internal */
 export const InputS3InventorySignatureVersion$inboundSchema: z.ZodType<
   InputS3InventorySignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3InventorySignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3InventorySignatureVersion);
 /** @internal */
 export const InputS3InventorySignatureVersion$outboundSchema: z.ZodType<
-  InputS3InventorySignatureVersion,
+  string,
   z.ZodTypeDef,
   InputS3InventorySignatureVersion
-> = z.union([
-  z.nativeEnum(InputS3InventorySignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3InventorySignatureVersion);
 
 /** @internal */
 export const InputS3InventoryPreprocess$inboundSchema: z.ZodType<
@@ -701,20 +669,13 @@ export const InputS3InventoryTagAfterProcessing$inboundSchema: z.ZodType<
   InputS3InventoryTagAfterProcessing,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputS3InventoryTagAfterProcessing),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputS3InventoryTagAfterProcessing);
 /** @internal */
 export const InputS3InventoryTagAfterProcessing$outboundSchema: z.ZodType<
-  InputS3InventoryTagAfterProcessing,
+  string,
   z.ZodTypeDef,
   InputS3InventoryTagAfterProcessing
-> = z.union([
-  z.nativeEnum(InputS3InventoryTagAfterProcessing),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputS3InventoryTagAfterProcessing);
 
 /** @internal */
 export const InputS3Inventory$inboundSchema: z.ZodType<