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

package/src/models/outputnewrelic.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 OutputNewrelicRegion$inboundSchema: z.ZodType<
   OutputNewrelicRegion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicRegion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicRegion);
 /** @internal */
 export const OutputNewrelicRegion$outboundSchema: z.ZodType<
-  OutputNewrelicRegion,
+  string,
   z.ZodTypeDef,
   OutputNewrelicRegion
-> = z.union([
-  z.nativeEnum(OutputNewrelicRegion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicRegion);
 
 /** @internal */
 export const FieldName$inboundSchema: z.ZodType<
   FieldName,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(FieldName),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(FieldName);
 /** @internal */
 export const FieldName$outboundSchema: z.ZodType<
-  FieldName,
+  string,
   z.ZodTypeDef,
   FieldName
-> = z.union([
-  z.nativeEnum(FieldName),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(FieldName);
 
 /** @internal */
 export const OutputNewrelicMetadatum$inboundSchema: z.ZodType<
@@ -522,20 +504,13 @@ export const OutputNewrelicFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputNewrelicFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicFailedRequestLoggingMode);
 /** @internal */
 export const OutputNewrelicFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputNewrelicFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputNewrelicFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputNewrelicFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputNewrelicResponseRetrySetting$inboundSchema: z.ZodType<
@@ -644,100 +619,65 @@ export const OutputNewrelicBackpressureBehavior$inboundSchema: z.ZodType<
   OutputNewrelicBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicBackpressureBehavior);
 /** @internal */
 export const OutputNewrelicBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicBackpressureBehavior);
 
 /** @internal */
 export const OutputNewrelicAuthenticationMethod$inboundSchema: z.ZodType<
   OutputNewrelicAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicAuthenticationMethod);
 /** @internal */
 export const OutputNewrelicAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputNewrelicAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputNewrelicAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputNewrelicAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicAuthenticationMethod);
 
 /** @internal */
 export const OutputNewrelicMode$inboundSchema: z.ZodType<
   OutputNewrelicMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicMode);
 /** @internal */
 export const OutputNewrelicMode$outboundSchema: z.ZodType<
-  OutputNewrelicMode,
+  string,
   z.ZodTypeDef,
   OutputNewrelicMode
-> = z.union([
-  z.nativeEnum(OutputNewrelicMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicMode);
 
 /** @internal */
 export const OutputNewrelicCompression$inboundSchema: z.ZodType<
   OutputNewrelicCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicCompression);
 /** @internal */
 export const OutputNewrelicCompression$outboundSchema: z.ZodType<
-  OutputNewrelicCompression,
+  string,
   z.ZodTypeDef,
   OutputNewrelicCompression
-> = z.union([
-  z.nativeEnum(OutputNewrelicCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicCompression);
 
 /** @internal */
 export const OutputNewrelicQueueFullBehavior$inboundSchema: z.ZodType<
   OutputNewrelicQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicQueueFullBehavior);
 /** @internal */
 export const OutputNewrelicQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicQueueFullBehavior);
 
 /** @internal */
 export const OutputNewrelicPqControls$inboundSchema: z.ZodType<

package/src/models/outputnewrelicevents.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";
 
@@ -382,20 +378,13 @@ export const OutputNewrelicEventsRegion$inboundSchema: z.ZodType<
   OutputNewrelicEventsRegion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsRegion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsRegion);
 /** @internal */
 export const OutputNewrelicEventsRegion$outboundSchema: z.ZodType<
-  OutputNewrelicEventsRegion,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsRegion
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsRegion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsRegion);
 
 /** @internal */
 export const OutputNewrelicEventsExtraHttpHeader$inboundSchema: z.ZodType<
@@ -448,21 +437,14 @@ export const OutputNewrelicEventsFailedRequestLoggingMode$inboundSchema:
     OutputNewrelicEventsFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputNewrelicEventsFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputNewrelicEventsFailedRequestLoggingMode);
 /** @internal */
 export const OutputNewrelicEventsFailedRequestLoggingMode$outboundSchema:
   z.ZodType<
-    OutputNewrelicEventsFailedRequestLoggingMode,
+    string,
     z.ZodTypeDef,
     OutputNewrelicEventsFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputNewrelicEventsFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(OutputNewrelicEventsFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputNewrelicEventsResponseRetrySetting$inboundSchema: z.ZodType<
@@ -583,100 +565,65 @@ export const OutputNewrelicEventsBackpressureBehavior$inboundSchema: z.ZodType<
   OutputNewrelicEventsBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsBackpressureBehavior);
 /** @internal */
 export const OutputNewrelicEventsBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicEventsBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsBackpressureBehavior);
 
 /** @internal */
 export const OutputNewrelicEventsAuthenticationMethod$inboundSchema: z.ZodType<
   OutputNewrelicEventsAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsAuthenticationMethod);
 /** @internal */
 export const OutputNewrelicEventsAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputNewrelicEventsAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsAuthenticationMethod);
 
 /** @internal */
 export const OutputNewrelicEventsMode$inboundSchema: z.ZodType<
   OutputNewrelicEventsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsMode);
 /** @internal */
 export const OutputNewrelicEventsMode$outboundSchema: z.ZodType<
-  OutputNewrelicEventsMode,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsMode
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsMode);
 
 /** @internal */
 export const OutputNewrelicEventsCompression$inboundSchema: z.ZodType<
   OutputNewrelicEventsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsCompression);
 /** @internal */
 export const OutputNewrelicEventsCompression$outboundSchema: z.ZodType<
-  OutputNewrelicEventsCompression,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsCompression
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsCompression);
 
 /** @internal */
 export const OutputNewrelicEventsQueueFullBehavior$inboundSchema: z.ZodType<
   OutputNewrelicEventsQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsQueueFullBehavior);
 /** @internal */
 export const OutputNewrelicEventsQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicEventsQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsQueueFullBehavior);
 
 /** @internal */
 export const OutputNewrelicEventsPqControls$inboundSchema: z.ZodType<

package/src/models/outputopentelemetry.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";
 
@@ -590,99 +586,61 @@ export const OutputOpenTelemetryProtocol$inboundSchema: z.ZodType<
   OutputOpenTelemetryProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryProtocol);
 /** @internal */
 export const OutputOpenTelemetryProtocol$outboundSchema: z.ZodType<
-  OutputOpenTelemetryProtocol,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryProtocol
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryProtocol);
 
 /** @internal */
 export const OutputOpenTelemetryOTLPVersion$inboundSchema: z.ZodType<
   OutputOpenTelemetryOTLPVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryOTLPVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryOTLPVersion);
 /** @internal */
 export const OutputOpenTelemetryOTLPVersion$outboundSchema: z.ZodType<
-  OutputOpenTelemetryOTLPVersion,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryOTLPVersion
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryOTLPVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryOTLPVersion);
 
 /** @internal */
 export const OutputOpenTelemetryCompressCompression$inboundSchema: z.ZodType<
   OutputOpenTelemetryCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryCompressCompression);
 /** @internal */
 export const OutputOpenTelemetryCompressCompression$outboundSchema: z.ZodType<
-  OutputOpenTelemetryCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryCompressCompression
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryCompressCompression);
 
 /** @internal */
 export const OutputOpenTelemetryHttpCompressCompression$inboundSchema:
   z.ZodType<OutputOpenTelemetryHttpCompressCompression, z.ZodTypeDef, unknown> =
-    z
-      .union([
-        z.nativeEnum(OutputOpenTelemetryHttpCompressCompression),
-        z.string().transform(catchUnrecognizedEnum),
-      ]);
+    openEnums.inboundSchema(OutputOpenTelemetryHttpCompressCompression);
 /** @internal */
 export const OutputOpenTelemetryHttpCompressCompression$outboundSchema:
-  z.ZodType<
-    OutputOpenTelemetryHttpCompressCompression,
-    z.ZodTypeDef,
-    OutputOpenTelemetryHttpCompressCompression
-  > = z.union([
-    z.nativeEnum(OutputOpenTelemetryHttpCompressCompression),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputOpenTelemetryHttpCompressCompression> =
+    openEnums.outboundSchema(OutputOpenTelemetryHttpCompressCompression);
 
 /** @internal */
 export const OutputOpenTelemetryAuthenticationType$inboundSchema: z.ZodType<
   OutputOpenTelemetryAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryAuthenticationType);
 /** @internal */
 export const OutputOpenTelemetryAuthenticationType$outboundSchema: z.ZodType<
-  OutputOpenTelemetryAuthenticationType,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryAuthenticationType
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryAuthenticationType);
 
 /** @internal */
 export const OutputOpenTelemetryMetadatum$inboundSchema: z.ZodType<
@@ -734,41 +692,24 @@ export const OutputOpenTelemetryFailedRequestLoggingMode$inboundSchema:
     OutputOpenTelemetryFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputOpenTelemetryFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputOpenTelemetryFailedRequestLoggingMode);
 /** @internal */
 export const OutputOpenTelemetryFailedRequestLoggingMode$outboundSchema:
-  z.ZodType<
-    OutputOpenTelemetryFailedRequestLoggingMode,
-    z.ZodTypeDef,
-    OutputOpenTelemetryFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputOpenTelemetryFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputOpenTelemetryFailedRequestLoggingMode> =
+    openEnums.outboundSchema(OutputOpenTelemetryFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputOpenTelemetryBackpressureBehavior$inboundSchema: z.ZodType<
   OutputOpenTelemetryBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryBackpressureBehavior);
 /** @internal */
 export const OutputOpenTelemetryBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputOpenTelemetryBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryBackpressureBehavior);
 
 /** @internal */
 export const OutputOpenTelemetryOauthParam$inboundSchema: z.ZodType<
@@ -1022,40 +963,26 @@ export const OutputOpenTelemetryMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputOpenTelemetryMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryMinimumTLSVersion);
 /** @internal */
 export const OutputOpenTelemetryMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputOpenTelemetryMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryMinimumTLSVersion);
 
 /** @internal */
 export const OutputOpenTelemetryMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputOpenTelemetryMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryMaximumTLSVersion);
 /** @internal */
 export const OutputOpenTelemetryMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputOpenTelemetryMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryMaximumTLSVersion);
 
 /** @internal */
 export const OutputOpenTelemetryTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -1134,60 +1061,39 @@ export const OutputOpenTelemetryMode$inboundSchema: z.ZodType<
   OutputOpenTelemetryMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryMode);
 /** @internal */
 export const OutputOpenTelemetryMode$outboundSchema: z.ZodType<
-  OutputOpenTelemetryMode,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryMode
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryMode);
 
 /** @internal */
 export const OutputOpenTelemetryPqCompressCompression$inboundSchema: z.ZodType<
   OutputOpenTelemetryPqCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryPqCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryPqCompressCompression);
 /** @internal */
 export const OutputOpenTelemetryPqCompressCompression$outboundSchema: z.ZodType<
-  OutputOpenTelemetryPqCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryPqCompressCompression
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryPqCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryPqCompressCompression);
 
 /** @internal */
 export const OutputOpenTelemetryQueueFullBehavior$inboundSchema: z.ZodType<
   OutputOpenTelemetryQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryQueueFullBehavior);
 /** @internal */
 export const OutputOpenTelemetryQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputOpenTelemetryQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryQueueFullBehavior);
 
 /** @internal */
 export const OutputOpenTelemetryPqControls$inboundSchema: z.ZodType<