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

package/src/models/outputopentelemetry.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 OutputOpenTelemetryType = {
-  OpenTelemetry: "open_telemetry",
-} as const;
-export type OutputOpenTelemetryType = ClosedEnum<
-  typeof OutputOpenTelemetryType
->;
-
 /**
  * Select a transport option for OpenTelemetry
  */
@@ -359,7 +348,7 @@ export type OutputOpenTelemetry = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputOpenTelemetryType;
+  type: "open_telemetry";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -576,113 +565,66 @@ export type OutputOpenTelemetry = {
   pqControls?: OutputOpenTelemetryPqControls | undefined;
 };
 
-/** @internal */
-export const OutputOpenTelemetryType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputOpenTelemetryType
-> = z.nativeEnum(OutputOpenTelemetryType);
-/** @internal */
-export const OutputOpenTelemetryType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputOpenTelemetryType
-> = OutputOpenTelemetryType$inboundSchema;
-
 /** @internal */
 export const OutputOpenTelemetryProtocol$inboundSchema: z.ZodType<
   OutputOpenTelemetryProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryProtocol);
 /** @internal */
 export const OutputOpenTelemetryProtocol$outboundSchema: z.ZodType<
-  OutputOpenTelemetryProtocol,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryProtocol
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryProtocol);
 
 /** @internal */
 export const OutputOpenTelemetryOTLPVersion$inboundSchema: z.ZodType<
   OutputOpenTelemetryOTLPVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryOTLPVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryOTLPVersion);
 /** @internal */
 export const OutputOpenTelemetryOTLPVersion$outboundSchema: z.ZodType<
-  OutputOpenTelemetryOTLPVersion,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryOTLPVersion
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryOTLPVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryOTLPVersion);
 
 /** @internal */
 export const OutputOpenTelemetryCompressCompression$inboundSchema: z.ZodType<
   OutputOpenTelemetryCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryCompressCompression);
 /** @internal */
 export const OutputOpenTelemetryCompressCompression$outboundSchema: z.ZodType<
-  OutputOpenTelemetryCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryCompressCompression
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryCompressCompression);
 
 /** @internal */
 export const OutputOpenTelemetryHttpCompressCompression$inboundSchema:
   z.ZodType<OutputOpenTelemetryHttpCompressCompression, z.ZodTypeDef, unknown> =
-    z
-      .union([
-        z.nativeEnum(OutputOpenTelemetryHttpCompressCompression),
-        z.string().transform(catchUnrecognizedEnum),
-      ]);
+    openEnums.inboundSchema(OutputOpenTelemetryHttpCompressCompression);
 /** @internal */
 export const OutputOpenTelemetryHttpCompressCompression$outboundSchema:
-  z.ZodType<
-    OutputOpenTelemetryHttpCompressCompression,
-    z.ZodTypeDef,
-    OutputOpenTelemetryHttpCompressCompression
-  > = z.union([
-    z.nativeEnum(OutputOpenTelemetryHttpCompressCompression),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputOpenTelemetryHttpCompressCompression> =
+    openEnums.outboundSchema(OutputOpenTelemetryHttpCompressCompression);
 
 /** @internal */
 export const OutputOpenTelemetryAuthenticationType$inboundSchema: z.ZodType<
   OutputOpenTelemetryAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryAuthenticationType);
 /** @internal */
 export const OutputOpenTelemetryAuthenticationType$outboundSchema: z.ZodType<
-  OutputOpenTelemetryAuthenticationType,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryAuthenticationType
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryAuthenticationType);
 
 /** @internal */
 export const OutputOpenTelemetryMetadatum$inboundSchema: z.ZodType<
@@ -734,41 +676,24 @@ export const OutputOpenTelemetryFailedRequestLoggingMode$inboundSchema:
     OutputOpenTelemetryFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputOpenTelemetryFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputOpenTelemetryFailedRequestLoggingMode);
 /** @internal */
 export const OutputOpenTelemetryFailedRequestLoggingMode$outboundSchema:
-  z.ZodType<
-    OutputOpenTelemetryFailedRequestLoggingMode,
-    z.ZodTypeDef,
-    OutputOpenTelemetryFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputOpenTelemetryFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, OutputOpenTelemetryFailedRequestLoggingMode> =
+    openEnums.outboundSchema(OutputOpenTelemetryFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputOpenTelemetryBackpressureBehavior$inboundSchema: z.ZodType<
   OutputOpenTelemetryBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryBackpressureBehavior);
 /** @internal */
 export const OutputOpenTelemetryBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputOpenTelemetryBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryBackpressureBehavior);
 
 /** @internal */
 export const OutputOpenTelemetryOauthParam$inboundSchema: z.ZodType<
@@ -1022,40 +947,26 @@ export const OutputOpenTelemetryMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputOpenTelemetryMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryMinimumTLSVersion);
 /** @internal */
 export const OutputOpenTelemetryMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputOpenTelemetryMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryMinimumTLSVersion);
 
 /** @internal */
 export const OutputOpenTelemetryMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputOpenTelemetryMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryMaximumTLSVersion);
 /** @internal */
 export const OutputOpenTelemetryMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputOpenTelemetryMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryMaximumTLSVersion);
 
 /** @internal */
 export const OutputOpenTelemetryTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -1134,60 +1045,39 @@ export const OutputOpenTelemetryMode$inboundSchema: z.ZodType<
   OutputOpenTelemetryMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryMode);
 /** @internal */
 export const OutputOpenTelemetryMode$outboundSchema: z.ZodType<
-  OutputOpenTelemetryMode,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryMode
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryMode);
 
 /** @internal */
 export const OutputOpenTelemetryPqCompressCompression$inboundSchema: z.ZodType<
   OutputOpenTelemetryPqCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryPqCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryPqCompressCompression);
 /** @internal */
 export const OutputOpenTelemetryPqCompressCompression$outboundSchema: z.ZodType<
-  OutputOpenTelemetryPqCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryPqCompressCompression
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryPqCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryPqCompressCompression);
 
 /** @internal */
 export const OutputOpenTelemetryQueueFullBehavior$inboundSchema: z.ZodType<
   OutputOpenTelemetryQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputOpenTelemetryQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputOpenTelemetryQueueFullBehavior);
 /** @internal */
 export const OutputOpenTelemetryQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputOpenTelemetryQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputOpenTelemetryQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputOpenTelemetryQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputOpenTelemetryQueueFullBehavior);
 
 /** @internal */
 export const OutputOpenTelemetryPqControls$inboundSchema: z.ZodType<
@@ -1231,7 +1121,7 @@ export const OutputOpenTelemetry$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputOpenTelemetryType$inboundSchema,
+  type: z.literal("open_telemetry"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -1315,7 +1205,7 @@ export const OutputOpenTelemetry$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputOpenTelemetry$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "open_telemetry";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -1387,7 +1277,7 @@ export const OutputOpenTelemetry$outboundSchema: z.ZodType<
   OutputOpenTelemetry
 > = z.object({
   id: z.string().optional(),
-  type: OutputOpenTelemetryType$outboundSchema,
+  type: z.literal("open_telemetry"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputprometheus.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 OutputPrometheusType = {
-  Prometheus: "prometheus",
-} as const;
-export type OutputPrometheusType = ClosedEnum<typeof OutputPrometheusType>;
-
 export type OutputPrometheusExtraHttpHeader = {
   name?: string | undefined;
   value: string;
@@ -215,7 +206,7 @@ export type OutputPrometheus = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputPrometheusType;
+  type: "prometheus";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -403,15 +394,6 @@ export type OutputPrometheus = {
   oauthHeaders?: Array<OutputPrometheusOauthHeader> | undefined;
 };
 
-/** @internal */
-export const OutputPrometheusType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputPrometheusType
-> = z.nativeEnum(OutputPrometheusType);
-/** @internal */
-export const OutputPrometheusType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputPrometheusType
-> = OutputPrometheusType$inboundSchema;
-
 /** @internal */
 export const OutputPrometheusExtraHttpHeader$inboundSchema: z.ZodType<
   OutputPrometheusExtraHttpHeader,
@@ -461,20 +443,13 @@ export const OutputPrometheusFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputPrometheusFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputPrometheusFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputPrometheusFailedRequestLoggingMode);
 /** @internal */
 export const OutputPrometheusFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputPrometheusFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputPrometheusFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputPrometheusFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputPrometheusFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputPrometheusResponseRetrySetting$inboundSchema: z.ZodType<
@@ -583,100 +558,65 @@ export const OutputPrometheusBackpressureBehavior$inboundSchema: z.ZodType<
   OutputPrometheusBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputPrometheusBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputPrometheusBackpressureBehavior);
 /** @internal */
 export const OutputPrometheusBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputPrometheusBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputPrometheusBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputPrometheusBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputPrometheusBackpressureBehavior);
 
 /** @internal */
 export const OutputPrometheusAuthenticationType$inboundSchema: z.ZodType<
   OutputPrometheusAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputPrometheusAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputPrometheusAuthenticationType);
 /** @internal */
 export const OutputPrometheusAuthenticationType$outboundSchema: z.ZodType<
-  OutputPrometheusAuthenticationType,
+  string,
   z.ZodTypeDef,
   OutputPrometheusAuthenticationType
-> = z.union([
-  z.nativeEnum(OutputPrometheusAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputPrometheusAuthenticationType);
 
 /** @internal */
 export const OutputPrometheusMode$inboundSchema: z.ZodType<
   OutputPrometheusMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputPrometheusMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputPrometheusMode);
 /** @internal */
 export const OutputPrometheusMode$outboundSchema: z.ZodType<
-  OutputPrometheusMode,
+  string,
   z.ZodTypeDef,
   OutputPrometheusMode
-> = z.union([
-  z.nativeEnum(OutputPrometheusMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputPrometheusMode);
 
 /** @internal */
 export const OutputPrometheusCompression$inboundSchema: z.ZodType<
   OutputPrometheusCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputPrometheusCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputPrometheusCompression);
 /** @internal */
 export const OutputPrometheusCompression$outboundSchema: z.ZodType<
-  OutputPrometheusCompression,
+  string,
   z.ZodTypeDef,
   OutputPrometheusCompression
-> = z.union([
-  z.nativeEnum(OutputPrometheusCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputPrometheusCompression);
 
 /** @internal */
 export const OutputPrometheusQueueFullBehavior$inboundSchema: z.ZodType<
   OutputPrometheusQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputPrometheusQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputPrometheusQueueFullBehavior);
 /** @internal */
 export const OutputPrometheusQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputPrometheusQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputPrometheusQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputPrometheusQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputPrometheusQueueFullBehavior);
 
 /** @internal */
 export const OutputPrometheusPqControls$inboundSchema: z.ZodType<
@@ -804,7 +744,7 @@ export const OutputPrometheus$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputPrometheusType$inboundSchema,
+  type: z.literal("prometheus"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -870,7 +810,7 @@ export const OutputPrometheus$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputPrometheus$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "prometheus";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -934,7 +874,7 @@ export const OutputPrometheus$outboundSchema: z.ZodType<
   OutputPrometheus
 > = z.object({
   id: z.string().optional(),
-  type: OutputPrometheusType$outboundSchema,
+  type: z.literal("prometheus"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),