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

package/src/models/outputfilesystem.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 OutputFilesystemType = {
-  Filesystem: "filesystem",
-} as const;
-export type OutputFilesystemType = ClosedEnum<typeof OutputFilesystemType>;
-
 /**
  * Format of the output data
  */
@@ -174,7 +165,7 @@ export type OutputFilesystem = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputFilesystemType;
+  type: "filesystem";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -334,154 +325,96 @@ export type OutputFilesystem = {
   maxRetryNum?: number | undefined;
 };
 
-/** @internal */
-export const OutputFilesystemType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputFilesystemType
-> = z.nativeEnum(OutputFilesystemType);
-/** @internal */
-export const OutputFilesystemType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputFilesystemType
-> = OutputFilesystemType$inboundSchema;
-
 /** @internal */
 export const OutputFilesystemDataFormat$inboundSchema: z.ZodType<
   OutputFilesystemDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemDataFormat);
 /** @internal */
 export const OutputFilesystemDataFormat$outboundSchema: z.ZodType<
-  OutputFilesystemDataFormat,
+  string,
   z.ZodTypeDef,
   OutputFilesystemDataFormat
-> = z.union([
-  z.nativeEnum(OutputFilesystemDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemDataFormat);
 
 /** @internal */
 export const OutputFilesystemBackpressureBehavior$inboundSchema: z.ZodType<
   OutputFilesystemBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemBackpressureBehavior);
 /** @internal */
 export const OutputFilesystemBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputFilesystemBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputFilesystemBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputFilesystemBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemBackpressureBehavior);
 
 /** @internal */
 export const OutputFilesystemDiskSpaceProtection$inboundSchema: z.ZodType<
   OutputFilesystemDiskSpaceProtection,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemDiskSpaceProtection),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemDiskSpaceProtection);
 /** @internal */
 export const OutputFilesystemDiskSpaceProtection$outboundSchema: z.ZodType<
-  OutputFilesystemDiskSpaceProtection,
+  string,
   z.ZodTypeDef,
   OutputFilesystemDiskSpaceProtection
-> = z.union([
-  z.nativeEnum(OutputFilesystemDiskSpaceProtection),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemDiskSpaceProtection);
 
 /** @internal */
 export const OutputFilesystemCompression$inboundSchema: z.ZodType<
   OutputFilesystemCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemCompression);
 /** @internal */
 export const OutputFilesystemCompression$outboundSchema: z.ZodType<
-  OutputFilesystemCompression,
+  string,
   z.ZodTypeDef,
   OutputFilesystemCompression
-> = z.union([
-  z.nativeEnum(OutputFilesystemCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemCompression);
 
 /** @internal */
 export const OutputFilesystemCompressionLevel$inboundSchema: z.ZodType<
   OutputFilesystemCompressionLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemCompressionLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemCompressionLevel);
 /** @internal */
 export const OutputFilesystemCompressionLevel$outboundSchema: z.ZodType<
-  OutputFilesystemCompressionLevel,
+  string,
   z.ZodTypeDef,
   OutputFilesystemCompressionLevel
-> = z.union([
-  z.nativeEnum(OutputFilesystemCompressionLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemCompressionLevel);
 
 /** @internal */
 export const OutputFilesystemParquetVersion$inboundSchema: z.ZodType<
   OutputFilesystemParquetVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemParquetVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemParquetVersion);
 /** @internal */
 export const OutputFilesystemParquetVersion$outboundSchema: z.ZodType<
-  OutputFilesystemParquetVersion,
+  string,
   z.ZodTypeDef,
   OutputFilesystemParquetVersion
-> = z.union([
-  z.nativeEnum(OutputFilesystemParquetVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemParquetVersion);
 
 /** @internal */
 export const OutputFilesystemDataPageVersion$inboundSchema: z.ZodType<
   OutputFilesystemDataPageVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputFilesystemDataPageVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputFilesystemDataPageVersion);
 /** @internal */
 export const OutputFilesystemDataPageVersion$outboundSchema: z.ZodType<
-  OutputFilesystemDataPageVersion,
+  string,
   z.ZodTypeDef,
   OutputFilesystemDataPageVersion
-> = z.union([
-  z.nativeEnum(OutputFilesystemDataPageVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputFilesystemDataPageVersion);
 
 /** @internal */
 export const OutputFilesystemKeyValueMetadatum$inboundSchema: z.ZodType<
@@ -534,7 +467,7 @@ export const OutputFilesystem$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputFilesystemType$inboundSchema,
+  type: z.literal("filesystem"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -594,7 +527,7 @@ export const OutputFilesystem$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputFilesystem$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "filesystem";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -646,7 +579,7 @@ export const OutputFilesystem$outboundSchema: z.ZodType<
   OutputFilesystem
 > = z.object({
   id: z.string().optional(),
-  type: OutputFilesystemType$outboundSchema,
+  type: z.literal("filesystem"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputgooglechronicle.ts

@@ -4,22 +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 OutputGoogleChronicleType = {
-  GoogleChronicle: "google_chronicle",
-} as const;
-export type OutputGoogleChronicleType = ClosedEnum<
-  typeof OutputGoogleChronicleType
->;
-
 export const OutputGoogleChronicleAPIVersion = {
   /**
    * V1
@@ -249,7 +238,7 @@ export type OutputGoogleChronicle = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputGoogleChronicleType;
+  type: "google_chronicle";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -430,55 +419,29 @@ export type OutputGoogleChronicle = {
   pqControls?: OutputGoogleChroniclePqControls | undefined;
 };
 
-/** @internal */
-export const OutputGoogleChronicleType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputGoogleChronicleType
-> = z.nativeEnum(OutputGoogleChronicleType);
-/** @internal */
-export const OutputGoogleChronicleType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputGoogleChronicleType
-> = OutputGoogleChronicleType$inboundSchema;
-
 /** @internal */
 export const OutputGoogleChronicleAPIVersion$inboundSchema: z.ZodType<
   OutputGoogleChronicleAPIVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputGoogleChronicleAPIVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputGoogleChronicleAPIVersion);
 /** @internal */
 export const OutputGoogleChronicleAPIVersion$outboundSchema: z.ZodType<
-  OutputGoogleChronicleAPIVersion,
+  string,
   z.ZodTypeDef,
   OutputGoogleChronicleAPIVersion
-> = z.union([
-  z.nativeEnum(OutputGoogleChronicleAPIVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputGoogleChronicleAPIVersion);
 
 /** @internal */
 export const OutputGoogleChronicleAuthenticationMethod$inboundSchema: z.ZodType<
   OutputGoogleChronicleAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputGoogleChronicleAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputGoogleChronicleAuthenticationMethod);
 /** @internal */
 export const OutputGoogleChronicleAuthenticationMethod$outboundSchema:
-  z.ZodType<
-    OutputGoogleChronicleAuthenticationMethod,
-    z.ZodTypeDef,
-    OutputGoogleChronicleAuthenticationMethod
-  > = z.union([
-    z.nativeEnum(OutputGoogleChronicleAuthenticationMethod),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputGoogleChronicleAuthenticationMethod> =
+    openEnums.outboundSchema(OutputGoogleChronicleAuthenticationMethod);
 
 /** @internal */
 export const OutputGoogleChronicleResponseRetrySetting$inboundSchema: z.ZodType<
@@ -601,20 +564,13 @@ export const SendEventsAs$inboundSchema: z.ZodType<
   SendEventsAs,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(SendEventsAs),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(SendEventsAs);
 /** @internal */
 export const SendEventsAs$outboundSchema: z.ZodType<
-  SendEventsAs,
+  string,
   z.ZodTypeDef,
   SendEventsAs
-> = z.union([
-  z.nativeEnum(SendEventsAs),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(SendEventsAs);
 
 /** @internal */
 export const OutputGoogleChronicleExtraHttpHeader$inboundSchema: z.ZodType<
@@ -667,42 +623,25 @@ export const OutputGoogleChronicleFailedRequestLoggingMode$inboundSchema:
     OutputGoogleChronicleFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputGoogleChronicleFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputGoogleChronicleFailedRequestLoggingMode);
 /** @internal */
 export const OutputGoogleChronicleFailedRequestLoggingMode$outboundSchema:
   z.ZodType<
-    OutputGoogleChronicleFailedRequestLoggingMode,
+    string,
     z.ZodTypeDef,
     OutputGoogleChronicleFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputGoogleChronicleFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(OutputGoogleChronicleFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputGoogleChronicleBackpressureBehavior$inboundSchema: z.ZodType<
   OutputGoogleChronicleBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputGoogleChronicleBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputGoogleChronicleBackpressureBehavior);
 /** @internal */
 export const OutputGoogleChronicleBackpressureBehavior$outboundSchema:
-  z.ZodType<
-    OutputGoogleChronicleBackpressureBehavior,
-    z.ZodTypeDef,
-    OutputGoogleChronicleBackpressureBehavior
-  > = z.union([
-    z.nativeEnum(OutputGoogleChronicleBackpressureBehavior),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputGoogleChronicleBackpressureBehavior> =
+    openEnums.outboundSchema(OutputGoogleChronicleBackpressureBehavior);
 
 /** @internal */
 export const ExtraLogType$inboundSchema: z.ZodType<
@@ -788,77 +727,49 @@ export function outputGoogleChronicleCustomLabelFromJSON(
 
 /** @internal */
 export const UDMType$inboundSchema: z.ZodType<UDMType, z.ZodTypeDef, unknown> =
-  z
-    .union([
-      z.nativeEnum(UDMType),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  openEnums.inboundSchema(UDMType);
 /** @internal */
-export const UDMType$outboundSchema: z.ZodType<UDMType, z.ZodTypeDef, UDMType> =
-  z.union([
-    z.nativeEnum(UDMType),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+export const UDMType$outboundSchema: z.ZodType<string, z.ZodTypeDef, UDMType> =
+  openEnums.outboundSchema(UDMType);
 
 /** @internal */
 export const OutputGoogleChronicleMode$inboundSchema: z.ZodType<
   OutputGoogleChronicleMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputGoogleChronicleMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputGoogleChronicleMode);
 /** @internal */
 export const OutputGoogleChronicleMode$outboundSchema: z.ZodType<
-  OutputGoogleChronicleMode,
+  string,
   z.ZodTypeDef,
   OutputGoogleChronicleMode
-> = z.union([
-  z.nativeEnum(OutputGoogleChronicleMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputGoogleChronicleMode);
 
 /** @internal */
 export const OutputGoogleChronicleCompression$inboundSchema: z.ZodType<
   OutputGoogleChronicleCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputGoogleChronicleCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputGoogleChronicleCompression);
 /** @internal */
 export const OutputGoogleChronicleCompression$outboundSchema: z.ZodType<
-  OutputGoogleChronicleCompression,
+  string,
   z.ZodTypeDef,
   OutputGoogleChronicleCompression
-> = z.union([
-  z.nativeEnum(OutputGoogleChronicleCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputGoogleChronicleCompression);
 
 /** @internal */
 export const OutputGoogleChronicleQueueFullBehavior$inboundSchema: z.ZodType<
   OutputGoogleChronicleQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputGoogleChronicleQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputGoogleChronicleQueueFullBehavior);
 /** @internal */
 export const OutputGoogleChronicleQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputGoogleChronicleQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputGoogleChronicleQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputGoogleChronicleQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputGoogleChronicleQueueFullBehavior);
 
 /** @internal */
 export const OutputGoogleChroniclePqControls$inboundSchema: z.ZodType<
@@ -902,7 +813,7 @@ export const OutputGoogleChronicle$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputGoogleChronicleType$inboundSchema,
+  type: z.literal("google_chronicle"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -967,7 +878,7 @@ export const OutputGoogleChronicle$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputGoogleChronicle$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "google_chronicle";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -1030,7 +941,7 @@ export const OutputGoogleChronicle$outboundSchema: z.ZodType<
   OutputGoogleChronicle
 > = z.object({
   id: z.string().optional(),
-  type: OutputGoogleChronicleType$outboundSchema,
+  type: z.literal("google_chronicle"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),