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

package/src/models/outputconfluentcloud.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";
 
@@ -619,40 +615,26 @@ export const OutputConfluentCloudMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputConfluentCloudMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudMinimumTLSVersion);
 /** @internal */
 export const OutputConfluentCloudMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputConfluentCloudMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudMinimumTLSVersion);
 
 /** @internal */
 export const OutputConfluentCloudMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputConfluentCloudMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudMaximumTLSVersion);
 /** @internal */
 export const OutputConfluentCloudMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputConfluentCloudMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudMaximumTLSVersion);
 
 /** @internal */
 export const OutputConfluentCloudTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -735,60 +717,39 @@ export const OutputConfluentCloudAcknowledgments$inboundSchema: z.ZodType<
   OutputConfluentCloudAcknowledgments,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudAcknowledgments),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(OutputConfluentCloudAcknowledgments);
 /** @internal */
 export const OutputConfluentCloudAcknowledgments$outboundSchema: z.ZodType<
-  OutputConfluentCloudAcknowledgments,
+  number,
   z.ZodTypeDef,
   OutputConfluentCloudAcknowledgments
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudAcknowledgments),
-  z.number().and(z.custom<Unrecognized<number>>()),
-]);
+> = openEnums.outboundSchemaInt(OutputConfluentCloudAcknowledgments);
 
 /** @internal */
 export const OutputConfluentCloudRecordDataFormat$inboundSchema: z.ZodType<
   OutputConfluentCloudRecordDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudRecordDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudRecordDataFormat);
 /** @internal */
 export const OutputConfluentCloudRecordDataFormat$outboundSchema: z.ZodType<
-  OutputConfluentCloudRecordDataFormat,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudRecordDataFormat
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudRecordDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudRecordDataFormat);
 
 /** @internal */
 export const OutputConfluentCloudCompression$inboundSchema: z.ZodType<
   OutputConfluentCloudCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudCompression);
 /** @internal */
 export const OutputConfluentCloudCompression$outboundSchema: z.ZodType<
-  OutputConfluentCloudCompression,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudCompression
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudCompression);
 
 /** @internal */
 export const OutputConfluentCloudAuth$inboundSchema: z.ZodType<
@@ -838,21 +799,18 @@ export const OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion$inboundSch
     OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion,
+  );
 /** @internal */
 export const OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion$outboundSchema:
   z.ZodType<
-    OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion,
+    string,
     z.ZodTypeDef,
     OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion
-  > = z.union([
-    z.nativeEnum(OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    OutputConfluentCloudKafkaSchemaRegistryMinimumTLSVersion,
+  );
 
 /** @internal */
 export const OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion$inboundSchema:
@@ -860,21 +818,18 @@ export const OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion$inboundSch
     OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion,
+  );
 /** @internal */
 export const OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion$outboundSchema:
   z.ZodType<
-    OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion,
+    string,
     z.ZodTypeDef,
     OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion
-  > = z.union([
-    z.nativeEnum(OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    OutputConfluentCloudKafkaSchemaRegistryMaximumTLSVersion,
+  );
 
 /** @internal */
 export const OutputConfluentCloudKafkaSchemaRegistryTLSSettingsClientSide$inboundSchema:
@@ -1045,40 +1000,26 @@ export const OutputConfluentCloudAuthenticationMethod$inboundSchema: z.ZodType<
   OutputConfluentCloudAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudAuthenticationMethod);
 /** @internal */
 export const OutputConfluentCloudAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputConfluentCloudAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudAuthenticationMethod);
 
 /** @internal */
 export const OutputConfluentCloudSASLMechanism$inboundSchema: z.ZodType<
   OutputConfluentCloudSASLMechanism,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudSASLMechanism),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudSASLMechanism);
 /** @internal */
 export const OutputConfluentCloudSASLMechanism$outboundSchema: z.ZodType<
-  OutputConfluentCloudSASLMechanism,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudSASLMechanism
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudSASLMechanism),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudSASLMechanism);
 
 /** @internal */
 export const OutputConfluentCloudOauthParam$inboundSchema: z.ZodType<
@@ -1274,81 +1215,50 @@ export const OutputConfluentCloudBackpressureBehavior$inboundSchema: z.ZodType<
   OutputConfluentCloudBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudBackpressureBehavior);
 /** @internal */
 export const OutputConfluentCloudBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputConfluentCloudBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudBackpressureBehavior);
 
 /** @internal */
 export const OutputConfluentCloudMode$inboundSchema: z.ZodType<
   OutputConfluentCloudMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudMode);
 /** @internal */
 export const OutputConfluentCloudMode$outboundSchema: z.ZodType<
-  OutputConfluentCloudMode,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudMode
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudMode);
 
 /** @internal */
 export const OutputConfluentCloudPqCompressCompression$inboundSchema: z.ZodType<
   OutputConfluentCloudPqCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudPqCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudPqCompressCompression);
 /** @internal */
 export const OutputConfluentCloudPqCompressCompression$outboundSchema:
-  z.ZodType<
-    OutputConfluentCloudPqCompressCompression,
-    z.ZodTypeDef,
-    OutputConfluentCloudPqCompressCompression
-  > = z.union([
-    z.nativeEnum(OutputConfluentCloudPqCompressCompression),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputConfluentCloudPqCompressCompression> =
+    openEnums.outboundSchema(OutputConfluentCloudPqCompressCompression);
 
 /** @internal */
 export const OutputConfluentCloudQueueFullBehavior$inboundSchema: z.ZodType<
   OutputConfluentCloudQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputConfluentCloudQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputConfluentCloudQueueFullBehavior);
 /** @internal */
 export const OutputConfluentCloudQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputConfluentCloudQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputConfluentCloudQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputConfluentCloudQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputConfluentCloudQueueFullBehavior);
 
 /** @internal */
 export const OutputConfluentCloudPqControls$inboundSchema: z.ZodType<

package/src/models/outputcriblhttp.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";
 
@@ -446,40 +442,26 @@ export const OutputCriblHttpMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputCriblHttpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpMinimumTLSVersion);
 /** @internal */
 export const OutputCriblHttpMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputCriblHttpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputCriblHttpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpMinimumTLSVersion);
 
 /** @internal */
 export const OutputCriblHttpMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputCriblHttpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpMaximumTLSVersion);
 /** @internal */
 export const OutputCriblHttpMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputCriblHttpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputCriblHttpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpMaximumTLSVersion);
 
 /** @internal */
 export const OutputCriblHttpTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -555,20 +537,13 @@ export const OutputCriblHttpCompression$inboundSchema: z.ZodType<
   OutputCriblHttpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpCompression);
 /** @internal */
 export const OutputCriblHttpCompression$outboundSchema: z.ZodType<
-  OutputCriblHttpCompression,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpCompression
-> = z.union([
-  z.nativeEnum(OutputCriblHttpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpCompression);
 
 /** @internal */
 export const OutputCriblHttpExtraHttpHeader$inboundSchema: z.ZodType<
@@ -619,20 +594,13 @@ export const OutputCriblHttpFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputCriblHttpFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpFailedRequestLoggingMode);
 /** @internal */
 export const OutputCriblHttpFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputCriblHttpFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputCriblHttpFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputCriblHttpResponseRetrySetting$inboundSchema: z.ZodType<
@@ -786,20 +754,13 @@ export const OutputCriblHttpBackpressureBehavior$inboundSchema: z.ZodType<
   OutputCriblHttpBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpBackpressureBehavior);
 /** @internal */
 export const OutputCriblHttpBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputCriblHttpBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputCriblHttpBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpBackpressureBehavior);
 
 /** @internal */
 export const OutputCriblHttpUrl$inboundSchema: z.ZodType<
@@ -848,60 +809,39 @@ export const OutputCriblHttpMode$inboundSchema: z.ZodType<
   OutputCriblHttpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpMode);
 /** @internal */
 export const OutputCriblHttpMode$outboundSchema: z.ZodType<
-  OutputCriblHttpMode,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpMode
-> = z.union([
-  z.nativeEnum(OutputCriblHttpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpMode);
 
 /** @internal */
 export const OutputCriblHttpPqCompressCompression$inboundSchema: z.ZodType<
   OutputCriblHttpPqCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpPqCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpPqCompressCompression);
 /** @internal */
 export const OutputCriblHttpPqCompressCompression$outboundSchema: z.ZodType<
-  OutputCriblHttpPqCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpPqCompressCompression
-> = z.union([
-  z.nativeEnum(OutputCriblHttpPqCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpPqCompressCompression);
 
 /** @internal */
 export const OutputCriblHttpQueueFullBehavior$inboundSchema: z.ZodType<
   OutputCriblHttpQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCriblHttpQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCriblHttpQueueFullBehavior);
 /** @internal */
 export const OutputCriblHttpQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputCriblHttpQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputCriblHttpQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputCriblHttpQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCriblHttpQueueFullBehavior);
 
 /** @internal */
 export const OutputCriblHttpPqControls$inboundSchema: z.ZodType<