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

package/src/models/outputdls3.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";
 
@@ -559,80 +555,52 @@ export const OutputDlS3AuthenticationMethod$inboundSchema: z.ZodType<
   OutputDlS3AuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3AuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3AuthenticationMethod);
 /** @internal */
 export const OutputDlS3AuthenticationMethod$outboundSchema: z.ZodType<
-  OutputDlS3AuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputDlS3AuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputDlS3AuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3AuthenticationMethod);
 
 /** @internal */
 export const OutputDlS3SignatureVersion$inboundSchema: z.ZodType<
   OutputDlS3SignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3SignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3SignatureVersion);
 /** @internal */
 export const OutputDlS3SignatureVersion$outboundSchema: z.ZodType<
-  OutputDlS3SignatureVersion,
+  string,
   z.ZodTypeDef,
   OutputDlS3SignatureVersion
-> = z.union([
-  z.nativeEnum(OutputDlS3SignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3SignatureVersion);
 
 /** @internal */
 export const OutputDlS3ObjectACL$inboundSchema: z.ZodType<
   OutputDlS3ObjectACL,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3ObjectACL),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3ObjectACL);
 /** @internal */
 export const OutputDlS3ObjectACL$outboundSchema: z.ZodType<
-  OutputDlS3ObjectACL,
+  string,
   z.ZodTypeDef,
   OutputDlS3ObjectACL
-> = z.union([
-  z.nativeEnum(OutputDlS3ObjectACL),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3ObjectACL);
 
 /** @internal */
 export const OutputDlS3StorageClass$inboundSchema: z.ZodType<
   OutputDlS3StorageClass,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3StorageClass),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3StorageClass);
 /** @internal */
 export const OutputDlS3StorageClass$outboundSchema: z.ZodType<
-  OutputDlS3StorageClass,
+  string,
   z.ZodTypeDef,
   OutputDlS3StorageClass
-> = z.union([
-  z.nativeEnum(OutputDlS3StorageClass),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3StorageClass);
 
 /** @internal */
 export const OutputDlS3ServerSideEncryptionForUploadedObjects$inboundSchema:
@@ -640,161 +608,107 @@ export const OutputDlS3ServerSideEncryptionForUploadedObjects$inboundSchema:
     OutputDlS3ServerSideEncryptionForUploadedObjects,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputDlS3ServerSideEncryptionForUploadedObjects),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputDlS3ServerSideEncryptionForUploadedObjects);
 /** @internal */
 export const OutputDlS3ServerSideEncryptionForUploadedObjects$outboundSchema:
   z.ZodType<
-    OutputDlS3ServerSideEncryptionForUploadedObjects,
+    string,
     z.ZodTypeDef,
     OutputDlS3ServerSideEncryptionForUploadedObjects
-  > = z.union([
-    z.nativeEnum(OutputDlS3ServerSideEncryptionForUploadedObjects),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    OutputDlS3ServerSideEncryptionForUploadedObjects,
+  );
 
 /** @internal */
 export const OutputDlS3DataFormat$inboundSchema: z.ZodType<
   OutputDlS3DataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3DataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3DataFormat);
 /** @internal */
 export const OutputDlS3DataFormat$outboundSchema: z.ZodType<
-  OutputDlS3DataFormat,
+  string,
   z.ZodTypeDef,
   OutputDlS3DataFormat
-> = z.union([
-  z.nativeEnum(OutputDlS3DataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3DataFormat);
 
 /** @internal */
 export const OutputDlS3BackpressureBehavior$inboundSchema: z.ZodType<
   OutputDlS3BackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3BackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3BackpressureBehavior);
 /** @internal */
 export const OutputDlS3BackpressureBehavior$outboundSchema: z.ZodType<
-  OutputDlS3BackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputDlS3BackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputDlS3BackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3BackpressureBehavior);
 
 /** @internal */
 export const OutputDlS3DiskSpaceProtection$inboundSchema: z.ZodType<
   OutputDlS3DiskSpaceProtection,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3DiskSpaceProtection),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3DiskSpaceProtection);
 /** @internal */
 export const OutputDlS3DiskSpaceProtection$outboundSchema: z.ZodType<
-  OutputDlS3DiskSpaceProtection,
+  string,
   z.ZodTypeDef,
   OutputDlS3DiskSpaceProtection
-> = z.union([
-  z.nativeEnum(OutputDlS3DiskSpaceProtection),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3DiskSpaceProtection);
 
 /** @internal */
 export const OutputDlS3Compression$inboundSchema: z.ZodType<
   OutputDlS3Compression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3Compression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3Compression);
 /** @internal */
 export const OutputDlS3Compression$outboundSchema: z.ZodType<
-  OutputDlS3Compression,
+  string,
   z.ZodTypeDef,
   OutputDlS3Compression
-> = z.union([
-  z.nativeEnum(OutputDlS3Compression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3Compression);
 
 /** @internal */
 export const OutputDlS3CompressionLevel$inboundSchema: z.ZodType<
   OutputDlS3CompressionLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3CompressionLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3CompressionLevel);
 /** @internal */
 export const OutputDlS3CompressionLevel$outboundSchema: z.ZodType<
-  OutputDlS3CompressionLevel,
+  string,
   z.ZodTypeDef,
   OutputDlS3CompressionLevel
-> = z.union([
-  z.nativeEnum(OutputDlS3CompressionLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3CompressionLevel);
 
 /** @internal */
 export const OutputDlS3ParquetVersion$inboundSchema: z.ZodType<
   OutputDlS3ParquetVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3ParquetVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3ParquetVersion);
 /** @internal */
 export const OutputDlS3ParquetVersion$outboundSchema: z.ZodType<
-  OutputDlS3ParquetVersion,
+  string,
   z.ZodTypeDef,
   OutputDlS3ParquetVersion
-> = z.union([
-  z.nativeEnum(OutputDlS3ParquetVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3ParquetVersion);
 
 /** @internal */
 export const OutputDlS3DataPageVersion$inboundSchema: z.ZodType<
   OutputDlS3DataPageVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDlS3DataPageVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDlS3DataPageVersion);
 /** @internal */
 export const OutputDlS3DataPageVersion$outboundSchema: z.ZodType<
-  OutputDlS3DataPageVersion,
+  string,
   z.ZodTypeDef,
   OutputDlS3DataPageVersion
-> = z.union([
-  z.nativeEnum(OutputDlS3DataPageVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDlS3DataPageVersion);
 
 /** @internal */
 export const OutputDlS3KeyValueMetadatum$inboundSchema: z.ZodType<

package/src/models/outputdynatracehttp.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";
 
@@ -433,20 +429,13 @@ export const OutputDynatraceHttpMethod$inboundSchema: z.ZodType<
   OutputDynatraceHttpMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpMethod);
 /** @internal */
 export const OutputDynatraceHttpMethod$outboundSchema: z.ZodType<
-  OutputDynatraceHttpMethod,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpMethod
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpMethod);
 
 /** @internal */
 export const OutputDynatraceHttpExtraHttpHeader$inboundSchema: z.ZodType<
@@ -499,21 +488,11 @@ export const OutputDynatraceHttpFailedRequestLoggingMode$inboundSchema:
     OutputDynatraceHttpFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputDynatraceHttpFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputDynatraceHttpFailedRequestLoggingMode);
 /** @internal */
 export const OutputDynatraceHttpFailedRequestLoggingMode$outboundSchema:
-  z.ZodType<
-    OutputDynatraceHttpFailedRequestLoggingMode,
-    z.ZodTypeDef,
-    OutputDynatraceHttpFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputDynatraceHttpFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputDynatraceHttpFailedRequestLoggingMode> =
+    openEnums.outboundSchema(OutputDynatraceHttpFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputDynatraceHttpResponseRetrySetting$inboundSchema: z.ZodType<
@@ -634,160 +613,104 @@ export const OutputDynatraceHttpBackpressureBehavior$inboundSchema: z.ZodType<
   OutputDynatraceHttpBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpBackpressureBehavior);
 /** @internal */
 export const OutputDynatraceHttpBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputDynatraceHttpBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpBackpressureBehavior);
 
 /** @internal */
 export const OutputDynatraceHttpAuthenticationType$inboundSchema: z.ZodType<
   OutputDynatraceHttpAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpAuthenticationType);
 /** @internal */
 export const OutputDynatraceHttpAuthenticationType$outboundSchema: z.ZodType<
-  OutputDynatraceHttpAuthenticationType,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpAuthenticationType
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpAuthenticationType);
 
 /** @internal */
 export const OutputDynatraceHttpFormat$inboundSchema: z.ZodType<
   OutputDynatraceHttpFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpFormat);
 /** @internal */
 export const OutputDynatraceHttpFormat$outboundSchema: z.ZodType<
-  OutputDynatraceHttpFormat,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpFormat
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpFormat);
 
 /** @internal */
 export const Endpoint$inboundSchema: z.ZodType<
   Endpoint,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(Endpoint),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(Endpoint);
 /** @internal */
 export const Endpoint$outboundSchema: z.ZodType<
-  Endpoint,
+  string,
   z.ZodTypeDef,
   Endpoint
-> = z.union([
-  z.nativeEnum(Endpoint),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(Endpoint);
 
 /** @internal */
 export const TelemetryType$inboundSchema: z.ZodType<
   TelemetryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TelemetryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TelemetryType);
 /** @internal */
 export const TelemetryType$outboundSchema: z.ZodType<
-  TelemetryType,
+  string,
   z.ZodTypeDef,
   TelemetryType
-> = z.union([
-  z.nativeEnum(TelemetryType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TelemetryType);
 
 /** @internal */
 export const OutputDynatraceHttpMode$inboundSchema: z.ZodType<
   OutputDynatraceHttpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpMode);
 /** @internal */
 export const OutputDynatraceHttpMode$outboundSchema: z.ZodType<
-  OutputDynatraceHttpMode,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpMode
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpMode);
 
 /** @internal */
 export const OutputDynatraceHttpCompression$inboundSchema: z.ZodType<
   OutputDynatraceHttpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpCompression);
 /** @internal */
 export const OutputDynatraceHttpCompression$outboundSchema: z.ZodType<
-  OutputDynatraceHttpCompression,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpCompression
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpCompression);
 
 /** @internal */
 export const OutputDynatraceHttpQueueFullBehavior$inboundSchema: z.ZodType<
   OutputDynatraceHttpQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDynatraceHttpQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDynatraceHttpQueueFullBehavior);
 /** @internal */
 export const OutputDynatraceHttpQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputDynatraceHttpQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputDynatraceHttpQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputDynatraceHttpQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDynatraceHttpQueueFullBehavior);
 
 /** @internal */
 export const OutputDynatraceHttpPqControls$inboundSchema: z.ZodType<