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

package/src/models/outputcloudflarer2.ts

@@ -4,20 +4,11 @@
 
 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 { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const OutputCloudflareR2Type = {
-  CloudflareR2: "cloudflare_r2",
-} as const;
-export type OutputCloudflareR2Type = ClosedEnum<typeof OutputCloudflareR2Type>;
-
 /**
  * AWS authentication method. Choose Auto to use IAM roles.
  */
@@ -239,7 +230,7 @@ export type OutputCloudflareR2 = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputCloudflareR2Type;
+  type: "cloudflare_r2";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -453,234 +444,148 @@ export type OutputCloudflareR2 = {
   maxRetryNum?: number | undefined;
 };
 
-/** @internal */
-export const OutputCloudflareR2Type$inboundSchema: z.ZodNativeEnum<
-  typeof OutputCloudflareR2Type
-> = z.nativeEnum(OutputCloudflareR2Type);
-/** @internal */
-export const OutputCloudflareR2Type$outboundSchema: z.ZodNativeEnum<
-  typeof OutputCloudflareR2Type
-> = OutputCloudflareR2Type$inboundSchema;
-
 /** @internal */
 export const OutputCloudflareR2AuthenticationMethod$inboundSchema: z.ZodType<
   OutputCloudflareR2AuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2AuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2AuthenticationMethod);
 /** @internal */
 export const OutputCloudflareR2AuthenticationMethod$outboundSchema: z.ZodType<
-  OutputCloudflareR2AuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2AuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2AuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2AuthenticationMethod);
 
 /** @internal */
 export const OutputCloudflareR2SignatureVersion$inboundSchema: z.ZodType<
   OutputCloudflareR2SignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2SignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2SignatureVersion);
 /** @internal */
 export const OutputCloudflareR2SignatureVersion$outboundSchema: z.ZodType<
-  OutputCloudflareR2SignatureVersion,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2SignatureVersion
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2SignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2SignatureVersion);
 
 /** @internal */
 export const OutputCloudflareR2StorageClass$inboundSchema: z.ZodType<
   OutputCloudflareR2StorageClass,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2StorageClass),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2StorageClass);
 /** @internal */
 export const OutputCloudflareR2StorageClass$outboundSchema: z.ZodType<
-  OutputCloudflareR2StorageClass,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2StorageClass
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2StorageClass),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2StorageClass);
 
 /** @internal */
 export const OutputCloudflareR2ServerSideEncryption$inboundSchema: z.ZodType<
   OutputCloudflareR2ServerSideEncryption,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2ServerSideEncryption),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2ServerSideEncryption);
 /** @internal */
 export const OutputCloudflareR2ServerSideEncryption$outboundSchema: z.ZodType<
-  OutputCloudflareR2ServerSideEncryption,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2ServerSideEncryption
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2ServerSideEncryption),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2ServerSideEncryption);
 
 /** @internal */
 export const OutputCloudflareR2DataFormat$inboundSchema: z.ZodType<
   OutputCloudflareR2DataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2DataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2DataFormat);
 /** @internal */
 export const OutputCloudflareR2DataFormat$outboundSchema: z.ZodType<
-  OutputCloudflareR2DataFormat,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2DataFormat
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2DataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2DataFormat);
 
 /** @internal */
 export const OutputCloudflareR2BackpressureBehavior$inboundSchema: z.ZodType<
   OutputCloudflareR2BackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2BackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2BackpressureBehavior);
 /** @internal */
 export const OutputCloudflareR2BackpressureBehavior$outboundSchema: z.ZodType<
-  OutputCloudflareR2BackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2BackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2BackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2BackpressureBehavior);
 
 /** @internal */
 export const OutputCloudflareR2DiskSpaceProtection$inboundSchema: z.ZodType<
   OutputCloudflareR2DiskSpaceProtection,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2DiskSpaceProtection),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2DiskSpaceProtection);
 /** @internal */
 export const OutputCloudflareR2DiskSpaceProtection$outboundSchema: z.ZodType<
-  OutputCloudflareR2DiskSpaceProtection,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2DiskSpaceProtection
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2DiskSpaceProtection),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2DiskSpaceProtection);
 
 /** @internal */
 export const OutputCloudflareR2Compression$inboundSchema: z.ZodType<
   OutputCloudflareR2Compression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2Compression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2Compression);
 /** @internal */
 export const OutputCloudflareR2Compression$outboundSchema: z.ZodType<
-  OutputCloudflareR2Compression,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2Compression
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2Compression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2Compression);
 
 /** @internal */
 export const OutputCloudflareR2CompressionLevel$inboundSchema: z.ZodType<
   OutputCloudflareR2CompressionLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2CompressionLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2CompressionLevel);
 /** @internal */
 export const OutputCloudflareR2CompressionLevel$outboundSchema: z.ZodType<
-  OutputCloudflareR2CompressionLevel,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2CompressionLevel
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2CompressionLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2CompressionLevel);
 
 /** @internal */
 export const OutputCloudflareR2ParquetVersion$inboundSchema: z.ZodType<
   OutputCloudflareR2ParquetVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2ParquetVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2ParquetVersion);
 /** @internal */
 export const OutputCloudflareR2ParquetVersion$outboundSchema: z.ZodType<
-  OutputCloudflareR2ParquetVersion,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2ParquetVersion
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2ParquetVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2ParquetVersion);
 
 /** @internal */
 export const OutputCloudflareR2DataPageVersion$inboundSchema: z.ZodType<
   OutputCloudflareR2DataPageVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudflareR2DataPageVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudflareR2DataPageVersion);
 /** @internal */
 export const OutputCloudflareR2DataPageVersion$outboundSchema: z.ZodType<
-  OutputCloudflareR2DataPageVersion,
+  string,
   z.ZodTypeDef,
   OutputCloudflareR2DataPageVersion
-> = z.union([
-  z.nativeEnum(OutputCloudflareR2DataPageVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudflareR2DataPageVersion);
 
 /** @internal */
 export const OutputCloudflareR2KeyValueMetadatum$inboundSchema: z.ZodType<
@@ -734,7 +639,7 @@ export const OutputCloudflareR2$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputCloudflareR2Type$inboundSchema,
+  type: z.literal("cloudflare_r2"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -812,7 +717,7 @@ export const OutputCloudflareR2$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputCloudflareR2$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "cloudflare_r2";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -879,7 +784,7 @@ export const OutputCloudflareR2$outboundSchema: z.ZodType<
   OutputCloudflareR2
 > = z.object({
   id: z.string().optional(),
-  type: OutputCloudflareR2Type$outboundSchema,
+  type: z.literal("cloudflare_r2"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputcloudwatch.ts

@@ -4,20 +4,11 @@
 
 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 { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const OutputCloudwatchType = {
-  Cloudwatch: "cloudwatch",
-} as const;
-export type OutputCloudwatchType = ClosedEnum<typeof OutputCloudwatchType>;
-
 /**
  * AWS authentication method. Choose Auto to use IAM roles.
  */
@@ -135,7 +126,7 @@ export type OutputCloudwatch = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputCloudwatchType;
+  type: "cloudwatch";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -262,114 +253,70 @@ export type OutputCloudwatch = {
   pqControls?: OutputCloudwatchPqControls | undefined;
 };
 
-/** @internal */
-export const OutputCloudwatchType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputCloudwatchType
-> = z.nativeEnum(OutputCloudwatchType);
-/** @internal */
-export const OutputCloudwatchType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputCloudwatchType
-> = OutputCloudwatchType$inboundSchema;
-
 /** @internal */
 export const OutputCloudwatchAuthenticationMethod$inboundSchema: z.ZodType<
   OutputCloudwatchAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudwatchAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudwatchAuthenticationMethod);
 /** @internal */
 export const OutputCloudwatchAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputCloudwatchAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputCloudwatchAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputCloudwatchAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudwatchAuthenticationMethod);
 
 /** @internal */
 export const OutputCloudwatchBackpressureBehavior$inboundSchema: z.ZodType<
   OutputCloudwatchBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudwatchBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudwatchBackpressureBehavior);
 /** @internal */
 export const OutputCloudwatchBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputCloudwatchBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputCloudwatchBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputCloudwatchBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudwatchBackpressureBehavior);
 
 /** @internal */
 export const OutputCloudwatchMode$inboundSchema: z.ZodType<
   OutputCloudwatchMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudwatchMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudwatchMode);
 /** @internal */
 export const OutputCloudwatchMode$outboundSchema: z.ZodType<
-  OutputCloudwatchMode,
+  string,
   z.ZodTypeDef,
   OutputCloudwatchMode
-> = z.union([
-  z.nativeEnum(OutputCloudwatchMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudwatchMode);
 
 /** @internal */
 export const OutputCloudwatchCompression$inboundSchema: z.ZodType<
   OutputCloudwatchCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudwatchCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudwatchCompression);
 /** @internal */
 export const OutputCloudwatchCompression$outboundSchema: z.ZodType<
-  OutputCloudwatchCompression,
+  string,
   z.ZodTypeDef,
   OutputCloudwatchCompression
-> = z.union([
-  z.nativeEnum(OutputCloudwatchCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudwatchCompression);
 
 /** @internal */
 export const OutputCloudwatchQueueFullBehavior$inboundSchema: z.ZodType<
   OutputCloudwatchQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputCloudwatchQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputCloudwatchQueueFullBehavior);
 /** @internal */
 export const OutputCloudwatchQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputCloudwatchQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputCloudwatchQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputCloudwatchQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputCloudwatchQueueFullBehavior);
 
 /** @internal */
 export const OutputCloudwatchPqControls$inboundSchema: z.ZodType<
@@ -411,7 +358,7 @@ export const OutputCloudwatch$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputCloudwatchType$inboundSchema,
+  type: z.literal("cloudwatch"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -455,7 +402,7 @@ export const OutputCloudwatch$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputCloudwatch$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "cloudwatch";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -499,7 +446,7 @@ export const OutputCloudwatch$outboundSchema: z.ZodType<
   OutputCloudwatch
 > = z.object({
   id: z.string().optional(),
-  type: OutputCloudwatchType$outboundSchema,
+  type: z.literal("cloudwatch"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),