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

package/src/models/outputdynatraceotlp.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";
 
@@ -465,79 +461,48 @@ export const OutputDynatraceOtlpProtocol$inboundSchema: z.ZodType<
   OutputDynatraceOtlpProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOtlpProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOtlpProtocol);
 /** @internal */
 export const OutputDynatraceOtlpProtocol$outboundSchema: z.ZodType<
-  OutputDynatraceOtlpProtocol,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOtlpProtocol
-> = z.union([
-  z.nativeEnum(OutputDynatraceOtlpProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOtlpProtocol);
 
 /** @internal */
 export const OutputDynatraceOTLPOTLPVersion$inboundSchema: z.ZodType<
   OutputDynatraceOTLPOTLPVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOTLPOTLPVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOTLPOTLPVersion);
 /** @internal */
 export const OutputDynatraceOTLPOTLPVersion$outboundSchema: z.ZodType<
-  OutputDynatraceOTLPOTLPVersion,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOTLPOTLPVersion
-> = z.union([
-  z.nativeEnum(OutputDynatraceOTLPOTLPVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOTLPOTLPVersion);
 
 /** @internal */
 export const OutputDynatraceOtlpCompressCompression$inboundSchema: z.ZodType<
   OutputDynatraceOtlpCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOtlpCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOtlpCompressCompression);
 /** @internal */
 export const OutputDynatraceOtlpCompressCompression$outboundSchema: z.ZodType<
-  OutputDynatraceOtlpCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOtlpCompressCompression
-> = z.union([
-  z.nativeEnum(OutputDynatraceOtlpCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOtlpCompressCompression);
 
 /** @internal */
 export const OutputDynatraceOtlpHttpCompressCompression$inboundSchema:
   z.ZodType<OutputDynatraceOtlpHttpCompressCompression, z.ZodTypeDef, unknown> =
-    z
-      .union([
-        z.nativeEnum(OutputDynatraceOtlpHttpCompressCompression),
-        z.string().transform(catchUnrecognizedEnum),
-      ]);
+    openEnums.inboundSchema(OutputDynatraceOtlpHttpCompressCompression);
 /** @internal */
 export const OutputDynatraceOtlpHttpCompressCompression$outboundSchema:
-  z.ZodType<
-    OutputDynatraceOtlpHttpCompressCompression,
-    z.ZodTypeDef,
-    OutputDynatraceOtlpHttpCompressCompression
-  > = z.union([
-    z.nativeEnum(OutputDynatraceOtlpHttpCompressCompression),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputDynatraceOtlpHttpCompressCompression> =
+    openEnums.outboundSchema(OutputDynatraceOtlpHttpCompressCompression);
 
 /** @internal */
 export const OutputDynatraceOtlpMetadatum$inboundSchema: z.ZodType<
@@ -589,61 +554,37 @@ export const OutputDynatraceOtlpFailedRequestLoggingMode$inboundSchema:
     OutputDynatraceOtlpFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputDynatraceOtlpFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputDynatraceOtlpFailedRequestLoggingMode);
 /** @internal */
 export const OutputDynatraceOtlpFailedRequestLoggingMode$outboundSchema:
-  z.ZodType<
-    OutputDynatraceOtlpFailedRequestLoggingMode,
-    z.ZodTypeDef,
-    OutputDynatraceOtlpFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputDynatraceOtlpFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputDynatraceOtlpFailedRequestLoggingMode> =
+    openEnums.outboundSchema(OutputDynatraceOtlpFailedRequestLoggingMode);
 
 /** @internal */
 export const EndpointType$inboundSchema: z.ZodType<
   EndpointType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(EndpointType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(EndpointType);
 /** @internal */
 export const EndpointType$outboundSchema: z.ZodType<
-  EndpointType,
+  string,
   z.ZodTypeDef,
   EndpointType
-> = z.union([
-  z.nativeEnum(EndpointType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(EndpointType);
 
 /** @internal */
 export const OutputDynatraceOtlpBackpressureBehavior$inboundSchema: z.ZodType<
   OutputDynatraceOtlpBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOtlpBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOtlpBackpressureBehavior);
 /** @internal */
 export const OutputDynatraceOtlpBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputDynatraceOtlpBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOtlpBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputDynatraceOtlpBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOtlpBackpressureBehavior);
 
 /** @internal */
 export const OutputDynatraceOtlpExtraHttpHeader$inboundSchema: z.ZodType<
@@ -809,60 +750,39 @@ export const OutputDynatraceOtlpMode$inboundSchema: z.ZodType<
   OutputDynatraceOtlpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOtlpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOtlpMode);
 /** @internal */
 export const OutputDynatraceOtlpMode$outboundSchema: z.ZodType<
-  OutputDynatraceOtlpMode,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOtlpMode
-> = z.union([
-  z.nativeEnum(OutputDynatraceOtlpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOtlpMode);
 
 /** @internal */
 export const OutputDynatraceOtlpPqCompressCompression$inboundSchema: z.ZodType<
   OutputDynatraceOtlpPqCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOtlpPqCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOtlpPqCompressCompression);
 /** @internal */
 export const OutputDynatraceOtlpPqCompressCompression$outboundSchema: z.ZodType<
-  OutputDynatraceOtlpPqCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOtlpPqCompressCompression
-> = z.union([
-  z.nativeEnum(OutputDynatraceOtlpPqCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOtlpPqCompressCompression);
 
 /** @internal */
 export const OutputDynatraceOtlpQueueFullBehavior$inboundSchema: z.ZodType<
   OutputDynatraceOtlpQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceOtlpQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceOtlpQueueFullBehavior);
 /** @internal */
 export const OutputDynatraceOtlpQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputDynatraceOtlpQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputDynatraceOtlpQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputDynatraceOtlpQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceOtlpQueueFullBehavior);
 
 /** @internal */
 export const OutputDynatraceOtlpPqControls$inboundSchema: z.ZodType<

package/src/models/outputelastic.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";
 
@@ -500,20 +496,13 @@ export const OutputElasticFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputElasticFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticFailedRequestLoggingMode);
 /** @internal */
 export const OutputElasticFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputElasticFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputElasticFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputElasticFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputElasticResponseRetrySetting$inboundSchema: z.ZodType<
@@ -662,20 +651,13 @@ export const OutputElasticAuthenticationMethod$inboundSchema: z.ZodType<
   OutputElasticAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticAuthenticationMethod);
 /** @internal */
 export const OutputElasticAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputElasticAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputElasticAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputElasticAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticAuthenticationMethod);
 
 /** @internal */
 export const OutputElasticAuth$inboundSchema: z.ZodType<
@@ -739,60 +721,39 @@ export const ElasticVersion$inboundSchema: z.ZodType<
   ElasticVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ElasticVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ElasticVersion);
 /** @internal */
 export const ElasticVersion$outboundSchema: z.ZodType<
-  ElasticVersion,
+  string,
   z.ZodTypeDef,
   ElasticVersion
-> = z.union([
-  z.nativeEnum(ElasticVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ElasticVersion);
 
 /** @internal */
 export const WriteAction$inboundSchema: z.ZodType<
   WriteAction,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(WriteAction),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(WriteAction);
 /** @internal */
 export const WriteAction$outboundSchema: z.ZodType<
-  WriteAction,
+  string,
   z.ZodTypeDef,
   WriteAction
-> = z.union([
-  z.nativeEnum(WriteAction),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(WriteAction);
 
 /** @internal */
 export const OutputElasticBackpressureBehavior$inboundSchema: z.ZodType<
   OutputElasticBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticBackpressureBehavior);
 /** @internal */
 export const OutputElasticBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputElasticBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputElasticBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputElasticBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticBackpressureBehavior);
 
 /** @internal */
 export const OutputElasticUrl$inboundSchema: z.ZodType<
@@ -841,60 +802,39 @@ export const OutputElasticMode$inboundSchema: z.ZodType<
   OutputElasticMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticMode);
 /** @internal */
 export const OutputElasticMode$outboundSchema: z.ZodType<
-  OutputElasticMode,
+  string,
   z.ZodTypeDef,
   OutputElasticMode
-> = z.union([
-  z.nativeEnum(OutputElasticMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticMode);
 
 /** @internal */
 export const OutputElasticCompression$inboundSchema: z.ZodType<
   OutputElasticCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticCompression);
 /** @internal */
 export const OutputElasticCompression$outboundSchema: z.ZodType<
-  OutputElasticCompression,
+  string,
   z.ZodTypeDef,
   OutputElasticCompression
-> = z.union([
-  z.nativeEnum(OutputElasticCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticCompression);
 
 /** @internal */
 export const OutputElasticQueueFullBehavior$inboundSchema: z.ZodType<
   OutputElasticQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticQueueFullBehavior);
 /** @internal */
 export const OutputElasticQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputElasticQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputElasticQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputElasticQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticQueueFullBehavior);
 
 /** @internal */
 export const OutputElasticPqControls$inboundSchema: z.ZodType<

package/src/models/outputelasticcloud.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";
 
@@ -417,21 +413,11 @@ export function outputElasticCloudExtraHttpHeaderFromJSON(
 /** @internal */
 export const OutputElasticCloudFailedRequestLoggingMode$inboundSchema:
   z.ZodType<OutputElasticCloudFailedRequestLoggingMode, z.ZodTypeDef, unknown> =
-    z
-      .union([
-        z.nativeEnum(OutputElasticCloudFailedRequestLoggingMode),
-        z.string().transform(catchUnrecognizedEnum),
-      ]);
+    openEnums.inboundSchema(OutputElasticCloudFailedRequestLoggingMode);
 /** @internal */
 export const OutputElasticCloudFailedRequestLoggingMode$outboundSchema:
-  z.ZodType<
-    OutputElasticCloudFailedRequestLoggingMode,
-    z.ZodTypeDef,
-    OutputElasticCloudFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputElasticCloudFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputElasticCloudFailedRequestLoggingMode> =
+    openEnums.outboundSchema(OutputElasticCloudFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputElasticCloudExtraParam$inboundSchema: z.ZodType<
@@ -482,20 +468,13 @@ export const OutputElasticCloudAuthenticationMethod$inboundSchema: z.ZodType<
   OutputElasticCloudAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticCloudAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticCloudAuthenticationMethod);
 /** @internal */
 export const OutputElasticCloudAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputElasticCloudAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputElasticCloudAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputElasticCloudAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticCloudAuthenticationMethod);
 
 /** @internal */
 export const OutputElasticCloudAuth$inboundSchema: z.ZodType<
@@ -667,80 +646,52 @@ export const OutputElasticCloudBackpressureBehavior$inboundSchema: z.ZodType<
   OutputElasticCloudBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticCloudBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticCloudBackpressureBehavior);
 /** @internal */
 export const OutputElasticCloudBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputElasticCloudBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputElasticCloudBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputElasticCloudBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticCloudBackpressureBehavior);
 
 /** @internal */
 export const OutputElasticCloudMode$inboundSchema: z.ZodType<
   OutputElasticCloudMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticCloudMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticCloudMode);
 /** @internal */
 export const OutputElasticCloudMode$outboundSchema: z.ZodType<
-  OutputElasticCloudMode,
+  string,
   z.ZodTypeDef,
   OutputElasticCloudMode
-> = z.union([
-  z.nativeEnum(OutputElasticCloudMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticCloudMode);
 
 /** @internal */
 export const OutputElasticCloudCompression$inboundSchema: z.ZodType<
   OutputElasticCloudCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticCloudCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticCloudCompression);
 /** @internal */
 export const OutputElasticCloudCompression$outboundSchema: z.ZodType<
-  OutputElasticCloudCompression,
+  string,
   z.ZodTypeDef,
   OutputElasticCloudCompression
-> = z.union([
-  z.nativeEnum(OutputElasticCloudCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticCloudCompression);
 
 /** @internal */
 export const OutputElasticCloudQueueFullBehavior$inboundSchema: z.ZodType<
   OutputElasticCloudQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputElasticCloudQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputElasticCloudQueueFullBehavior);
 /** @internal */
 export const OutputElasticCloudQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputElasticCloudQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputElasticCloudQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputElasticCloudQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputElasticCloudQueueFullBehavior);
 
 /** @internal */
 export const OutputElasticCloudPqControls$inboundSchema: z.ZodType<