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

package/src/models/outputstatsd.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 OutputStatsdType = {
-  Statsd: "statsd",
-} as const;
-export type OutputStatsdType = ClosedEnum<typeof OutputStatsdType>;
-
 /**
  * Protocol to use when communicating with the destination.
  */
@@ -129,7 +120,7 @@ export type OutputStatsd = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputStatsdType;
+  type: "statsd";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -230,114 +221,70 @@ export type OutputStatsd = {
   pqControls?: OutputStatsdPqControls | undefined;
 };
 
-/** @internal */
-export const OutputStatsdType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputStatsdType
-> = z.nativeEnum(OutputStatsdType);
-/** @internal */
-export const OutputStatsdType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputStatsdType
-> = OutputStatsdType$inboundSchema;
-
 /** @internal */
 export const OutputStatsdDestinationProtocol$inboundSchema: z.ZodType<
   OutputStatsdDestinationProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdDestinationProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdDestinationProtocol);
 /** @internal */
 export const OutputStatsdDestinationProtocol$outboundSchema: z.ZodType<
-  OutputStatsdDestinationProtocol,
+  string,
   z.ZodTypeDef,
   OutputStatsdDestinationProtocol
-> = z.union([
-  z.nativeEnum(OutputStatsdDestinationProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdDestinationProtocol);
 
 /** @internal */
 export const OutputStatsdBackpressureBehavior$inboundSchema: z.ZodType<
   OutputStatsdBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdBackpressureBehavior);
 /** @internal */
 export const OutputStatsdBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputStatsdBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputStatsdBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputStatsdBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdBackpressureBehavior);
 
 /** @internal */
 export const OutputStatsdMode$inboundSchema: z.ZodType<
   OutputStatsdMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdMode);
 /** @internal */
 export const OutputStatsdMode$outboundSchema: z.ZodType<
-  OutputStatsdMode,
+  string,
   z.ZodTypeDef,
   OutputStatsdMode
-> = z.union([
-  z.nativeEnum(OutputStatsdMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdMode);
 
 /** @internal */
 export const OutputStatsdCompression$inboundSchema: z.ZodType<
   OutputStatsdCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdCompression);
 /** @internal */
 export const OutputStatsdCompression$outboundSchema: z.ZodType<
-  OutputStatsdCompression,
+  string,
   z.ZodTypeDef,
   OutputStatsdCompression
-> = z.union([
-  z.nativeEnum(OutputStatsdCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdCompression);
 
 /** @internal */
 export const OutputStatsdQueueFullBehavior$inboundSchema: z.ZodType<
   OutputStatsdQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdQueueFullBehavior);
 /** @internal */
 export const OutputStatsdQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputStatsdQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputStatsdQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputStatsdQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdQueueFullBehavior);
 
 /** @internal */
 export const OutputStatsdPqControls$inboundSchema: z.ZodType<
@@ -379,7 +326,7 @@ export const OutputStatsd$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputStatsdType$inboundSchema,
+  type: z.literal("statsd"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -414,7 +361,7 @@ export const OutputStatsd$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputStatsd$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "statsd";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -450,7 +397,7 @@ export const OutputStatsd$outboundSchema: z.ZodType<
   OutputStatsd
 > = z.object({
   id: z.string().optional(),
-  type: OutputStatsdType$outboundSchema,
+  type: z.literal("statsd"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputstatsdext.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 OutputStatsdExtType = {
-  StatsdExt: "statsd_ext",
-} as const;
-export type OutputStatsdExtType = ClosedEnum<typeof OutputStatsdExtType>;
-
 /**
  * Protocol to use when communicating with the destination.
  */
@@ -131,7 +122,7 @@ export type OutputStatsdExt = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputStatsdExtType;
+  type: "statsd_ext";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -232,114 +223,70 @@ export type OutputStatsdExt = {
   pqControls?: OutputStatsdExtPqControls | undefined;
 };
 
-/** @internal */
-export const OutputStatsdExtType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputStatsdExtType
-> = z.nativeEnum(OutputStatsdExtType);
-/** @internal */
-export const OutputStatsdExtType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputStatsdExtType
-> = OutputStatsdExtType$inboundSchema;
-
 /** @internal */
 export const OutputStatsdExtDestinationProtocol$inboundSchema: z.ZodType<
   OutputStatsdExtDestinationProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtDestinationProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtDestinationProtocol);
 /** @internal */
 export const OutputStatsdExtDestinationProtocol$outboundSchema: z.ZodType<
-  OutputStatsdExtDestinationProtocol,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtDestinationProtocol
-> = z.union([
-  z.nativeEnum(OutputStatsdExtDestinationProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtDestinationProtocol);
 
 /** @internal */
 export const OutputStatsdExtBackpressureBehavior$inboundSchema: z.ZodType<
   OutputStatsdExtBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtBackpressureBehavior);
 /** @internal */
 export const OutputStatsdExtBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputStatsdExtBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputStatsdExtBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtBackpressureBehavior);
 
 /** @internal */
 export const OutputStatsdExtMode$inboundSchema: z.ZodType<
   OutputStatsdExtMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtMode);
 /** @internal */
 export const OutputStatsdExtMode$outboundSchema: z.ZodType<
-  OutputStatsdExtMode,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtMode
-> = z.union([
-  z.nativeEnum(OutputStatsdExtMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtMode);
 
 /** @internal */
 export const OutputStatsdExtCompression$inboundSchema: z.ZodType<
   OutputStatsdExtCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtCompression);
 /** @internal */
 export const OutputStatsdExtCompression$outboundSchema: z.ZodType<
-  OutputStatsdExtCompression,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtCompression
-> = z.union([
-  z.nativeEnum(OutputStatsdExtCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtCompression);
 
 /** @internal */
 export const OutputStatsdExtQueueFullBehavior$inboundSchema: z.ZodType<
   OutputStatsdExtQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtQueueFullBehavior);
 /** @internal */
 export const OutputStatsdExtQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputStatsdExtQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputStatsdExtQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtQueueFullBehavior);
 
 /** @internal */
 export const OutputStatsdExtPqControls$inboundSchema: z.ZodType<
@@ -381,7 +328,7 @@ export const OutputStatsdExt$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputStatsdExtType$inboundSchema,
+  type: z.literal("statsd_ext"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -416,7 +363,7 @@ export const OutputStatsdExt$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputStatsdExt$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "statsd_ext";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -452,7 +399,7 @@ export const OutputStatsdExt$outboundSchema: z.ZodType<
   OutputStatsdExt
 > = z.object({
   id: z.string().optional(),
-  type: OutputStatsdExtType$outboundSchema,
+  type: z.literal("statsd_ext"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputsumologic.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 OutputSumoLogicType = {
-  SumoLogic: "sumo_logic",
-} as const;
-export type OutputSumoLogicType = ClosedEnum<typeof OutputSumoLogicType>;
-
 /**
  * Preserve the raw event format instead of JSONifying it
  */
@@ -195,7 +186,7 @@ export type OutputSumoLogic = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputSumoLogicType;
+  type: "sumo_logic";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -341,34 +332,18 @@ export type OutputSumoLogic = {
   pqControls?: OutputSumoLogicPqControls | undefined;
 };
 
-/** @internal */
-export const OutputSumoLogicType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputSumoLogicType
-> = z.nativeEnum(OutputSumoLogicType);
-/** @internal */
-export const OutputSumoLogicType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputSumoLogicType
-> = OutputSumoLogicType$inboundSchema;
-
 /** @internal */
 export const OutputSumoLogicDataFormat$inboundSchema: z.ZodType<
   OutputSumoLogicDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicDataFormat);
 /** @internal */
 export const OutputSumoLogicDataFormat$outboundSchema: z.ZodType<
-  OutputSumoLogicDataFormat,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicDataFormat
-> = z.union([
-  z.nativeEnum(OutputSumoLogicDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicDataFormat);
 
 /** @internal */
 export const OutputSumoLogicExtraHttpHeader$inboundSchema: z.ZodType<
@@ -419,20 +394,13 @@ export const OutputSumoLogicFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputSumoLogicFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicFailedRequestLoggingMode);
 /** @internal */
 export const OutputSumoLogicFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputSumoLogicFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputSumoLogicFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputSumoLogicResponseRetrySetting$inboundSchema: z.ZodType<
@@ -541,80 +509,52 @@ export const OutputSumoLogicBackpressureBehavior$inboundSchema: z.ZodType<
   OutputSumoLogicBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicBackpressureBehavior);
 /** @internal */
 export const OutputSumoLogicBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputSumoLogicBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputSumoLogicBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicBackpressureBehavior);
 
 /** @internal */
 export const OutputSumoLogicMode$inboundSchema: z.ZodType<
   OutputSumoLogicMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicMode);
 /** @internal */
 export const OutputSumoLogicMode$outboundSchema: z.ZodType<
-  OutputSumoLogicMode,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicMode
-> = z.union([
-  z.nativeEnum(OutputSumoLogicMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicMode);
 
 /** @internal */
 export const OutputSumoLogicCompression$inboundSchema: z.ZodType<
   OutputSumoLogicCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicCompression);
 /** @internal */
 export const OutputSumoLogicCompression$outboundSchema: z.ZodType<
-  OutputSumoLogicCompression,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicCompression
-> = z.union([
-  z.nativeEnum(OutputSumoLogicCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicCompression);
 
 /** @internal */
 export const OutputSumoLogicQueueFullBehavior$inboundSchema: z.ZodType<
   OutputSumoLogicQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicQueueFullBehavior);
 /** @internal */
 export const OutputSumoLogicQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputSumoLogicQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputSumoLogicQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicQueueFullBehavior);
 
 /** @internal */
 export const OutputSumoLogicPqControls$inboundSchema: z.ZodType<
@@ -656,7 +596,7 @@ export const OutputSumoLogic$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputSumoLogicType$inboundSchema,
+  type: z.literal("sumo_logic"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -708,7 +648,7 @@ export const OutputSumoLogic$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputSumoLogic$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "sumo_logic";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -758,7 +698,7 @@ export const OutputSumoLogic$outboundSchema: z.ZodType<
   OutputSumoLogic
 > = z.object({
   id: z.string().optional(),
-  type: OutputSumoLogicType$outboundSchema,
+  type: z.literal("sumo_logic"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),