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

package/src/models/inputkafka.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";
 
@@ -545,40 +541,26 @@ export const InputKafkaMode$inboundSchema: z.ZodType<
   InputKafkaMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaMode);
 /** @internal */
 export const InputKafkaMode$outboundSchema: z.ZodType<
-  InputKafkaMode,
+  string,
   z.ZodTypeDef,
   InputKafkaMode
-> = z.union([
-  z.nativeEnum(InputKafkaMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaMode);
 
 /** @internal */
 export const InputKafkaCompression$inboundSchema: z.ZodType<
   InputKafkaCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaCompression);
 /** @internal */
 export const InputKafkaCompression$outboundSchema: z.ZodType<
-  InputKafkaCompression,
+  string,
   z.ZodTypeDef,
   InputKafkaCompression
-> = z.union([
-  z.nativeEnum(InputKafkaCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaCompression);
 
 /** @internal */
 export const InputKafkaPqControls$inboundSchema: z.ZodType<
@@ -713,21 +695,14 @@ export const InputKafkaKafkaSchemaRegistryMinimumTLSVersion$inboundSchema:
     InputKafkaKafkaSchemaRegistryMinimumTLSVersion,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputKafkaKafkaSchemaRegistryMinimumTLSVersion),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputKafkaKafkaSchemaRegistryMinimumTLSVersion);
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryMinimumTLSVersion$outboundSchema:
   z.ZodType<
-    InputKafkaKafkaSchemaRegistryMinimumTLSVersion,
+    string,
     z.ZodTypeDef,
     InputKafkaKafkaSchemaRegistryMinimumTLSVersion
-  > = z.union([
-    z.nativeEnum(InputKafkaKafkaSchemaRegistryMinimumTLSVersion),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(InputKafkaKafkaSchemaRegistryMinimumTLSVersion);
 
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryMaximumTLSVersion$inboundSchema:
@@ -735,21 +710,14 @@ export const InputKafkaKafkaSchemaRegistryMaximumTLSVersion$inboundSchema:
     InputKafkaKafkaSchemaRegistryMaximumTLSVersion,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputKafkaKafkaSchemaRegistryMaximumTLSVersion),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputKafkaKafkaSchemaRegistryMaximumTLSVersion);
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryMaximumTLSVersion$outboundSchema:
   z.ZodType<
-    InputKafkaKafkaSchemaRegistryMaximumTLSVersion,
+    string,
     z.ZodTypeDef,
     InputKafkaKafkaSchemaRegistryMaximumTLSVersion
-  > = z.union([
-    z.nativeEnum(InputKafkaKafkaSchemaRegistryMaximumTLSVersion),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(InputKafkaKafkaSchemaRegistryMaximumTLSVersion);
 
 /** @internal */
 export const InputKafkaKafkaSchemaRegistryTLSSettingsClientSide$inboundSchema:
@@ -909,40 +877,26 @@ export const InputKafkaAuthenticationMethod$inboundSchema: z.ZodType<
   InputKafkaAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaAuthenticationMethod);
 /** @internal */
 export const InputKafkaAuthenticationMethod$outboundSchema: z.ZodType<
-  InputKafkaAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputKafkaAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputKafkaAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaAuthenticationMethod);
 
 /** @internal */
 export const InputKafkaSASLMechanism$inboundSchema: z.ZodType<
   InputKafkaSASLMechanism,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaSASLMechanism),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaSASLMechanism);
 /** @internal */
 export const InputKafkaSASLMechanism$outboundSchema: z.ZodType<
-  InputKafkaSASLMechanism,
+  string,
   z.ZodTypeDef,
   InputKafkaSASLMechanism
-> = z.union([
-  z.nativeEnum(InputKafkaSASLMechanism),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaSASLMechanism);
 
 /** @internal */
 export const InputKafkaOauthParam$inboundSchema: z.ZodType<
@@ -1121,40 +1075,26 @@ export const InputKafkaMinimumTLSVersion$inboundSchema: z.ZodType<
   InputKafkaMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaMinimumTLSVersion);
 /** @internal */
 export const InputKafkaMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputKafkaMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputKafkaMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputKafkaMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaMinimumTLSVersion);
 
 /** @internal */
 export const InputKafkaMaximumTLSVersion$inboundSchema: z.ZodType<
   InputKafkaMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKafkaMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKafkaMaximumTLSVersion);
 /** @internal */
 export const InputKafkaMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputKafkaMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputKafkaMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputKafkaMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKafkaMaximumTLSVersion);
 
 /** @internal */
 export const InputKafkaTLSSettingsClientSide$inboundSchema: z.ZodType<

package/src/models/inputkinesis.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";
 
@@ -384,40 +380,26 @@ export const InputKinesisMode$inboundSchema: z.ZodType<
   InputKinesisMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisMode);
 /** @internal */
 export const InputKinesisMode$outboundSchema: z.ZodType<
-  InputKinesisMode,
+  string,
   z.ZodTypeDef,
   InputKinesisMode
-> = z.union([
-  z.nativeEnum(InputKinesisMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisMode);
 
 /** @internal */
 export const InputKinesisCompression$inboundSchema: z.ZodType<
   InputKinesisCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisCompression);
 /** @internal */
 export const InputKinesisCompression$outboundSchema: z.ZodType<
-  InputKinesisCompression,
+  string,
   z.ZodTypeDef,
   InputKinesisCompression
-> = z.union([
-  z.nativeEnum(InputKinesisCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisCompression);
 
 /** @internal */
 export const InputKinesisPqControls$inboundSchema: z.ZodType<
@@ -513,100 +495,65 @@ export const ShardIteratorStart$inboundSchema: z.ZodType<
   ShardIteratorStart,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ShardIteratorStart),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ShardIteratorStart);
 /** @internal */
 export const ShardIteratorStart$outboundSchema: z.ZodType<
-  ShardIteratorStart,
+  string,
   z.ZodTypeDef,
   ShardIteratorStart
-> = z.union([
-  z.nativeEnum(ShardIteratorStart),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ShardIteratorStart);
 
 /** @internal */
 export const InputKinesisRecordDataFormat$inboundSchema: z.ZodType<
   InputKinesisRecordDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisRecordDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisRecordDataFormat);
 /** @internal */
 export const InputKinesisRecordDataFormat$outboundSchema: z.ZodType<
-  InputKinesisRecordDataFormat,
+  string,
   z.ZodTypeDef,
   InputKinesisRecordDataFormat
-> = z.union([
-  z.nativeEnum(InputKinesisRecordDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisRecordDataFormat);
 
 /** @internal */
 export const ShardLoadBalancing$inboundSchema: z.ZodType<
   ShardLoadBalancing,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ShardLoadBalancing),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ShardLoadBalancing);
 /** @internal */
 export const ShardLoadBalancing$outboundSchema: z.ZodType<
-  ShardLoadBalancing,
+  string,
   z.ZodTypeDef,
   ShardLoadBalancing
-> = z.union([
-  z.nativeEnum(ShardLoadBalancing),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ShardLoadBalancing);
 
 /** @internal */
 export const InputKinesisAuthenticationMethod$inboundSchema: z.ZodType<
   InputKinesisAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisAuthenticationMethod);
 /** @internal */
 export const InputKinesisAuthenticationMethod$outboundSchema: z.ZodType<
-  InputKinesisAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputKinesisAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputKinesisAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisAuthenticationMethod);
 
 /** @internal */
 export const InputKinesisSignatureVersion$inboundSchema: z.ZodType<
   InputKinesisSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKinesisSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKinesisSignatureVersion);
 /** @internal */
 export const InputKinesisSignatureVersion$outboundSchema: z.ZodType<
-  InputKinesisSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputKinesisSignatureVersion
-> = z.union([
-  z.nativeEnum(InputKinesisSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKinesisSignatureVersion);
 
 /** @internal */
 export const InputKinesisMetadatum$inboundSchema: z.ZodType<

package/src/models/inputkubeevents.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";
 
@@ -213,40 +209,26 @@ export const InputKubeEventsMode$inboundSchema: z.ZodType<
   InputKubeEventsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeEventsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeEventsMode);
 /** @internal */
 export const InputKubeEventsMode$outboundSchema: z.ZodType<
-  InputKubeEventsMode,
+  string,
   z.ZodTypeDef,
   InputKubeEventsMode
-> = z.union([
-  z.nativeEnum(InputKubeEventsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeEventsMode);
 
 /** @internal */
 export const InputKubeEventsCompression$inboundSchema: z.ZodType<
   InputKubeEventsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeEventsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeEventsCompression);
 /** @internal */
 export const InputKubeEventsCompression$outboundSchema: z.ZodType<
-  InputKubeEventsCompression,
+  string,
   z.ZodTypeDef,
   InputKubeEventsCompression
-> = z.union([
-  z.nativeEnum(InputKubeEventsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeEventsCompression);
 
 /** @internal */
 export const InputKubeEventsPqControls$inboundSchema: z.ZodType<

package/src/models/inputkubelogs.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";
 
@@ -271,40 +267,26 @@ export const InputKubeLogsMode$inboundSchema: z.ZodType<
   InputKubeLogsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeLogsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeLogsMode);
 /** @internal */
 export const InputKubeLogsMode$outboundSchema: z.ZodType<
-  InputKubeLogsMode,
+  string,
   z.ZodTypeDef,
   InputKubeLogsMode
-> = z.union([
-  z.nativeEnum(InputKubeLogsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeLogsMode);
 
 /** @internal */
 export const InputKubeLogsPqCompression$inboundSchema: z.ZodType<
   InputKubeLogsPqCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeLogsPqCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeLogsPqCompression);
 /** @internal */
 export const InputKubeLogsPqCompression$outboundSchema: z.ZodType<
-  InputKubeLogsPqCompression,
+  string,
   z.ZodTypeDef,
   InputKubeLogsPqCompression
-> = z.union([
-  z.nativeEnum(InputKubeLogsPqCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeLogsPqCompression);
 
 /** @internal */
 export const InputKubeLogsPqControls$inboundSchema: z.ZodType<
@@ -486,20 +468,13 @@ export const InputKubeLogsPersistenceCompression$inboundSchema: z.ZodType<
   InputKubeLogsPersistenceCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeLogsPersistenceCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeLogsPersistenceCompression);
 /** @internal */
 export const InputKubeLogsPersistenceCompression$outboundSchema: z.ZodType<
-  InputKubeLogsPersistenceCompression,
+  string,
   z.ZodTypeDef,
   InputKubeLogsPersistenceCompression
-> = z.union([
-  z.nativeEnum(InputKubeLogsPersistenceCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeLogsPersistenceCompression);
 
 /** @internal */
 export const InputKubeLogsDiskSpooling$inboundSchema: z.ZodType<

package/src/models/inputkubemetrics.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";
 
@@ -250,40 +246,26 @@ export const InputKubeMetricsMode$inboundSchema: z.ZodType<
   InputKubeMetricsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeMetricsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeMetricsMode);
 /** @internal */
 export const InputKubeMetricsMode$outboundSchema: z.ZodType<
-  InputKubeMetricsMode,
+  string,
   z.ZodTypeDef,
   InputKubeMetricsMode
-> = z.union([
-  z.nativeEnum(InputKubeMetricsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeMetricsMode);
 
 /** @internal */
 export const InputKubeMetricsCompression$inboundSchema: z.ZodType<
   InputKubeMetricsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeMetricsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeMetricsCompression);
 /** @internal */
 export const InputKubeMetricsCompression$outboundSchema: z.ZodType<
-  InputKubeMetricsCompression,
+  string,
   z.ZodTypeDef,
   InputKubeMetricsCompression
-> = z.union([
-  z.nativeEnum(InputKubeMetricsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeMetricsCompression);
 
 /** @internal */
 export const InputKubeMetricsPqControls$inboundSchema: z.ZodType<
@@ -468,20 +450,13 @@ export const InputKubeMetricsDataCompressionFormat$inboundSchema: z.ZodType<
   InputKubeMetricsDataCompressionFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputKubeMetricsDataCompressionFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputKubeMetricsDataCompressionFormat);
 /** @internal */
 export const InputKubeMetricsDataCompressionFormat$outboundSchema: z.ZodType<
-  InputKubeMetricsDataCompressionFormat,
+  string,
   z.ZodTypeDef,
   InputKubeMetricsDataCompressionFormat
-> = z.union([
-  z.nativeEnum(InputKubeMetricsDataCompressionFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputKubeMetricsDataCompressionFormat);
 
 /** @internal */
 export const InputKubeMetricsPersistence$inboundSchema: z.ZodType<