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

package/src/models/outputsyslog.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 OutputSyslogType = {
-  Syslog: "syslog",
-} as const;
-export type OutputSyslogType = ClosedEnum<typeof OutputSyslogType>;
-
 /**
  * The network protocol to use for sending out syslog messages
  */
@@ -331,7 +322,7 @@ export type OutputSyslog = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputSyslogType;
+  type: "syslog";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -485,134 +476,83 @@ export type OutputSyslog = {
   pqControls?: OutputSyslogPqControls | undefined;
 };
 
-/** @internal */
-export const OutputSyslogType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputSyslogType
-> = z.nativeEnum(OutputSyslogType);
-/** @internal */
-export const OutputSyslogType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputSyslogType
-> = OutputSyslogType$inboundSchema;
-
 /** @internal */
 export const OutputSyslogProtocol$inboundSchema: z.ZodType<
   OutputSyslogProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogProtocol);
 /** @internal */
 export const OutputSyslogProtocol$outboundSchema: z.ZodType<
-  OutputSyslogProtocol,
+  string,
   z.ZodTypeDef,
   OutputSyslogProtocol
-> = z.union([
-  z.nativeEnum(OutputSyslogProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogProtocol);
 
 /** @internal */
 export const Facility$inboundSchema: z.ZodType<
   Facility,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(Facility),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(Facility);
 /** @internal */
 export const Facility$outboundSchema: z.ZodType<
-  Facility,
+  number,
   z.ZodTypeDef,
   Facility
-> = z.union([
-  z.nativeEnum(Facility),
-  z.number().and(z.custom<Unrecognized<number>>()),
-]);
+> = openEnums.outboundSchemaInt(Facility);
 
 /** @internal */
 export const OutputSyslogSeverity$inboundSchema: z.ZodType<
   OutputSyslogSeverity,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogSeverity),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(OutputSyslogSeverity);
 /** @internal */
 export const OutputSyslogSeverity$outboundSchema: z.ZodType<
-  OutputSyslogSeverity,
+  number,
   z.ZodTypeDef,
   OutputSyslogSeverity
-> = z.union([
-  z.nativeEnum(OutputSyslogSeverity),
-  z.number().and(z.custom<Unrecognized<number>>()),
-]);
+> = openEnums.outboundSchemaInt(OutputSyslogSeverity);
 
 /** @internal */
 export const OutputSyslogMessageFormat$inboundSchema: z.ZodType<
   OutputSyslogMessageFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMessageFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMessageFormat);
 /** @internal */
 export const OutputSyslogMessageFormat$outboundSchema: z.ZodType<
-  OutputSyslogMessageFormat,
+  string,
   z.ZodTypeDef,
   OutputSyslogMessageFormat
-> = z.union([
-  z.nativeEnum(OutputSyslogMessageFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMessageFormat);
 
 /** @internal */
 export const TimestampFormat$inboundSchema: z.ZodType<
   TimestampFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TimestampFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TimestampFormat);
 /** @internal */
 export const TimestampFormat$outboundSchema: z.ZodType<
-  TimestampFormat,
+  string,
   z.ZodTypeDef,
   TimestampFormat
-> = z.union([
-  z.nativeEnum(TimestampFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TimestampFormat);
 
 /** @internal */
 export const OutputSyslogTLS$inboundSchema: z.ZodType<
   OutputSyslogTLS,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogTLS),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogTLS);
 /** @internal */
 export const OutputSyslogTLS$outboundSchema: z.ZodType<
-  OutputSyslogTLS,
+  string,
   z.ZodTypeDef,
   OutputSyslogTLS
-> = z.union([
-  z.nativeEnum(OutputSyslogTLS),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogTLS);
 
 /** @internal */
 export const OutputSyslogHost$inboundSchema: z.ZodType<
@@ -670,40 +610,26 @@ export const OutputSyslogMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputSyslogMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMinimumTLSVersion);
 /** @internal */
 export const OutputSyslogMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputSyslogMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputSyslogMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputSyslogMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMinimumTLSVersion);
 
 /** @internal */
 export const OutputSyslogMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputSyslogMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMaximumTLSVersion);
 /** @internal */
 export const OutputSyslogMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputSyslogMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputSyslogMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputSyslogMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMaximumTLSVersion);
 
 /** @internal */
 export const OutputSyslogTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -778,80 +704,52 @@ export const OutputSyslogBackpressureBehavior$inboundSchema: z.ZodType<
   OutputSyslogBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogBackpressureBehavior);
 /** @internal */
 export const OutputSyslogBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputSyslogBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputSyslogBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputSyslogBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogBackpressureBehavior);
 
 /** @internal */
 export const OutputSyslogMode$inboundSchema: z.ZodType<
   OutputSyslogMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMode);
 /** @internal */
 export const OutputSyslogMode$outboundSchema: z.ZodType<
-  OutputSyslogMode,
+  string,
   z.ZodTypeDef,
   OutputSyslogMode
-> = z.union([
-  z.nativeEnum(OutputSyslogMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMode);
 
 /** @internal */
 export const OutputSyslogCompression$inboundSchema: z.ZodType<
   OutputSyslogCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogCompression);
 /** @internal */
 export const OutputSyslogCompression$outboundSchema: z.ZodType<
-  OutputSyslogCompression,
+  string,
   z.ZodTypeDef,
   OutputSyslogCompression
-> = z.union([
-  z.nativeEnum(OutputSyslogCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogCompression);
 
 /** @internal */
 export const OutputSyslogQueueFullBehavior$inboundSchema: z.ZodType<
   OutputSyslogQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogQueueFullBehavior);
 /** @internal */
 export const OutputSyslogQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputSyslogQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputSyslogQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputSyslogQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogQueueFullBehavior);
 
 /** @internal */
 export const OutputSyslogPqControls$inboundSchema: z.ZodType<
@@ -893,7 +791,7 @@ export const OutputSyslog$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputSyslogType$inboundSchema,
+  type: z.literal("syslog"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -942,7 +840,7 @@ export const OutputSyslog$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputSyslog$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "syslog";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -992,7 +890,7 @@ export const OutputSyslog$outboundSchema: z.ZodType<
   OutputSyslog
 > = z.object({
   id: z.string().optional(),
-  type: OutputSyslogType$outboundSchema,
+  type: z.literal("syslog"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputtcpjson.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 OutputTcpjsonType = {
-  Tcpjson: "tcpjson",
-} as const;
-export type OutputTcpjsonType = ClosedEnum<typeof OutputTcpjsonType>;
-
 /**
  * Codec to use to compress the data before sending
  */
@@ -237,7 +228,7 @@ export type OutputTcpjson = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputTcpjsonType;
+  type: "tcpjson";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -375,74 +366,44 @@ export type OutputTcpjson = {
   textSecret?: string | undefined;
 };
 
-/** @internal */
-export const OutputTcpjsonType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputTcpjsonType
-> = z.nativeEnum(OutputTcpjsonType);
-/** @internal */
-export const OutputTcpjsonType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputTcpjsonType
-> = OutputTcpjsonType$inboundSchema;
-
 /** @internal */
 export const OutputTcpjsonCompression$inboundSchema: z.ZodType<
   OutputTcpjsonCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonCompression);
 /** @internal */
 export const OutputTcpjsonCompression$outboundSchema: z.ZodType<
-  OutputTcpjsonCompression,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonCompression
-> = z.union([
-  z.nativeEnum(OutputTcpjsonCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonCompression);
 
 /** @internal */
 export const OutputTcpjsonMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputTcpjsonMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonMinimumTLSVersion);
 /** @internal */
 export const OutputTcpjsonMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputTcpjsonMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputTcpjsonMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonMinimumTLSVersion);
 
 /** @internal */
 export const OutputTcpjsonMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputTcpjsonMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonMaximumTLSVersion);
 /** @internal */
 export const OutputTcpjsonMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputTcpjsonMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputTcpjsonMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonMaximumTLSVersion);
 
 /** @internal */
 export const OutputTcpjsonTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -518,60 +479,39 @@ export const OutputTcpjsonBackpressureBehavior$inboundSchema: z.ZodType<
   OutputTcpjsonBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonBackpressureBehavior);
 /** @internal */
 export const OutputTcpjsonBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputTcpjsonBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputTcpjsonBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonBackpressureBehavior);
 
 /** @internal */
 export const OutputTcpjsonAuthenticationMethod$inboundSchema: z.ZodType<
   OutputTcpjsonAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonAuthenticationMethod);
 /** @internal */
 export const OutputTcpjsonAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputTcpjsonAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputTcpjsonAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonAuthenticationMethod);
 
 /** @internal */
 export const OutputTcpjsonTLS$inboundSchema: z.ZodType<
   OutputTcpjsonTLS,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonTLS),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonTLS);
 /** @internal */
 export const OutputTcpjsonTLS$outboundSchema: z.ZodType<
-  OutputTcpjsonTLS,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonTLS
-> = z.union([
-  z.nativeEnum(OutputTcpjsonTLS),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonTLS);
 
 /** @internal */
 export const OutputTcpjsonHost$inboundSchema: z.ZodType<
@@ -629,60 +569,39 @@ export const OutputTcpjsonMode$inboundSchema: z.ZodType<
   OutputTcpjsonMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonMode);
 /** @internal */
 export const OutputTcpjsonMode$outboundSchema: z.ZodType<
-  OutputTcpjsonMode,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonMode
-> = z.union([
-  z.nativeEnum(OutputTcpjsonMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonMode);
 
 /** @internal */
 export const OutputTcpjsonPqCompressCompression$inboundSchema: z.ZodType<
   OutputTcpjsonPqCompressCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonPqCompressCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonPqCompressCompression);
 /** @internal */
 export const OutputTcpjsonPqCompressCompression$outboundSchema: z.ZodType<
-  OutputTcpjsonPqCompressCompression,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonPqCompressCompression
-> = z.union([
-  z.nativeEnum(OutputTcpjsonPqCompressCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonPqCompressCompression);
 
 /** @internal */
 export const OutputTcpjsonQueueFullBehavior$inboundSchema: z.ZodType<
   OutputTcpjsonQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputTcpjsonQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputTcpjsonQueueFullBehavior);
 /** @internal */
 export const OutputTcpjsonQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputTcpjsonQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputTcpjsonQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputTcpjsonQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputTcpjsonQueueFullBehavior);
 
 /** @internal */
 export const OutputTcpjsonPqControls$inboundSchema: z.ZodType<
@@ -724,7 +643,7 @@ export const OutputTcpjson$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputTcpjsonType$inboundSchema,
+  type: z.literal("tcpjson"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -770,7 +689,7 @@ export const OutputTcpjson$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputTcpjson$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "tcpjson";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -816,7 +735,7 @@ export const OutputTcpjson$outboundSchema: z.ZodType<
   OutputTcpjson
 > = z.object({
   id: z.string().optional(),
-  type: OutputTcpjsonType$outboundSchema,
+  type: z.literal("tcpjson"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),