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

package/src/models/inputprometheus.ts

@@ -5,20 +5,11 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 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 InputPrometheusType = {
-  Prometheus: "prometheus",
-} as const;
-export type InputPrometheusType = ClosedEnum<typeof InputPrometheusType>;
-
 export type InputPrometheusConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -236,7 +227,7 @@ export type InputPrometheus = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputPrometheusType;
+  type: "prometheus";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -402,15 +393,6 @@ export type InputPrometheus = {
   credentialsSecret?: string | undefined;
 };
 
-/** @internal */
-export const InputPrometheusType$inboundSchema: z.ZodNativeEnum<
-  typeof InputPrometheusType
-> = z.nativeEnum(InputPrometheusType);
-/** @internal */
-export const InputPrometheusType$outboundSchema: z.ZodNativeEnum<
-  typeof InputPrometheusType
-> = InputPrometheusType$inboundSchema;
-
 /** @internal */
 export const InputPrometheusConnection$inboundSchema: z.ZodType<
   InputPrometheusConnection,
@@ -458,40 +440,26 @@ export const InputPrometheusMode$inboundSchema: z.ZodType<
   InputPrometheusMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusMode);
 /** @internal */
 export const InputPrometheusMode$outboundSchema: z.ZodType<
-  InputPrometheusMode,
+  string,
   z.ZodTypeDef,
   InputPrometheusMode
-> = z.union([
-  z.nativeEnum(InputPrometheusMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusMode);
 
 /** @internal */
 export const InputPrometheusCompression$inboundSchema: z.ZodType<
   InputPrometheusCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusCompression);
 /** @internal */
 export const InputPrometheusCompression$outboundSchema: z.ZodType<
-  InputPrometheusCompression,
+  string,
   z.ZodTypeDef,
   InputPrometheusCompression
-> = z.union([
-  z.nativeEnum(InputPrometheusCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusCompression);
 
 /** @internal */
 export const InputPrometheusPqControls$inboundSchema: z.ZodType<
@@ -591,40 +559,26 @@ export const InputPrometheusDiscoveryType$inboundSchema: z.ZodType<
   InputPrometheusDiscoveryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusDiscoveryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusDiscoveryType);
 /** @internal */
 export const InputPrometheusDiscoveryType$outboundSchema: z.ZodType<
-  InputPrometheusDiscoveryType,
+  string,
   z.ZodTypeDef,
   InputPrometheusDiscoveryType
-> = z.union([
-  z.nativeEnum(InputPrometheusDiscoveryType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusDiscoveryType);
 
 /** @internal */
 export const InputPrometheusLogLevel$inboundSchema: z.ZodType<
   InputPrometheusLogLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusLogLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusLogLevel);
 /** @internal */
 export const InputPrometheusLogLevel$outboundSchema: z.ZodType<
-  InputPrometheusLogLevel,
+  string,
   z.ZodTypeDef,
   InputPrometheusLogLevel
-> = z.union([
-  z.nativeEnum(InputPrometheusLogLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusLogLevel);
 
 /** @internal */
 export const InputPrometheusMetadatum$inboundSchema: z.ZodType<
@@ -674,61 +628,37 @@ export const InputPrometheusAuthTypeAuthenticationMethod$inboundSchema:
     InputPrometheusAuthTypeAuthenticationMethod,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputPrometheusAuthTypeAuthenticationMethod),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputPrometheusAuthTypeAuthenticationMethod);
 /** @internal */
 export const InputPrometheusAuthTypeAuthenticationMethod$outboundSchema:
-  z.ZodType<
-    InputPrometheusAuthTypeAuthenticationMethod,
-    z.ZodTypeDef,
-    InputPrometheusAuthTypeAuthenticationMethod
-  > = z.union([
-    z.nativeEnum(InputPrometheusAuthTypeAuthenticationMethod),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  z.ZodType<string, z.ZodTypeDef, InputPrometheusAuthTypeAuthenticationMethod> =
+    openEnums.outboundSchema(InputPrometheusAuthTypeAuthenticationMethod);
 
 /** @internal */
 export const InputPrometheusRecordType$inboundSchema: z.ZodType<
   InputPrometheusRecordType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRecordType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRecordType);
 /** @internal */
 export const InputPrometheusRecordType$outboundSchema: z.ZodType<
-  InputPrometheusRecordType,
+  string,
   z.ZodTypeDef,
   InputPrometheusRecordType
-> = z.union([
-  z.nativeEnum(InputPrometheusRecordType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRecordType);
 
 /** @internal */
 export const MetricsProtocol$inboundSchema: z.ZodType<
   MetricsProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(MetricsProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(MetricsProtocol);
 /** @internal */
 export const MetricsProtocol$outboundSchema: z.ZodType<
-  MetricsProtocol,
+  string,
   z.ZodTypeDef,
   MetricsProtocol
-> = z.union([
-  z.nativeEnum(MetricsProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(MetricsProtocol);
 
 /** @internal */
 export const InputPrometheusAwsAuthenticationMethodAuthenticationMethod$inboundSchema:
@@ -736,21 +666,18 @@ export const InputPrometheusAwsAuthenticationMethodAuthenticationMethod$inboundS
     InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputPrometheusAwsAuthenticationMethodAuthenticationMethod),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(
+    InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
+  );
 /** @internal */
 export const InputPrometheusAwsAuthenticationMethodAuthenticationMethod$outboundSchema:
   z.ZodType<
-    InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
+    string,
     z.ZodTypeDef,
     InputPrometheusAwsAuthenticationMethodAuthenticationMethod
-  > = z.union([
-    z.nativeEnum(InputPrometheusAwsAuthenticationMethodAuthenticationMethod),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(
+    InputPrometheusAwsAuthenticationMethodAuthenticationMethod,
+  );
 
 /** @internal */
 export const InputPrometheusSearchFilter$inboundSchema: z.ZodType<
@@ -811,20 +738,13 @@ export const InputPrometheusSignatureVersion$inboundSchema: z.ZodType<
   InputPrometheusSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusSignatureVersion);
 /** @internal */
 export const InputPrometheusSignatureVersion$outboundSchema: z.ZodType<
-  InputPrometheusSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputPrometheusSignatureVersion
-> = z.union([
-  z.nativeEnum(InputPrometheusSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusSignatureVersion);
 
 /** @internal */
 export const InputPrometheus$inboundSchema: z.ZodType<
@@ -833,7 +753,7 @@ export const InputPrometheus$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputPrometheusType$inboundSchema,
+  type: z.literal("prometheus"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -889,7 +809,7 @@ export const InputPrometheus$inboundSchema: z.ZodType<
 /** @internal */
 export type InputPrometheus$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "prometheus";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -943,7 +863,7 @@ export const InputPrometheus$outboundSchema: z.ZodType<
   InputPrometheus
 > = z.object({
   id: z.string().optional(),
-  type: InputPrometheusType$outboundSchema,
+  type: z.literal("prometheus"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputprometheusrw.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 InputPrometheusRwType = {
-  PrometheusRw: "prometheus_rw",
-} as const;
-export type InputPrometheusRwType = ClosedEnum<typeof InputPrometheusRwType>;
-
 export type InputPrometheusRwConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -206,7 +197,7 @@ export type InputPrometheusRw = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputPrometheusRwType;
+  type: "prometheus_rw";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -347,15 +338,6 @@ export type InputPrometheusRw = {
   oauthHeaders?: Array<InputPrometheusRwOauthHeader> | undefined;
 };
 
-/** @internal */
-export const InputPrometheusRwType$inboundSchema: z.ZodNativeEnum<
-  typeof InputPrometheusRwType
-> = z.nativeEnum(InputPrometheusRwType);
-/** @internal */
-export const InputPrometheusRwType$outboundSchema: z.ZodNativeEnum<
-  typeof InputPrometheusRwType
-> = InputPrometheusRwType$inboundSchema;
-
 /** @internal */
 export const InputPrometheusRwConnection$inboundSchema: z.ZodType<
   InputPrometheusRwConnection,
@@ -405,40 +387,26 @@ export const InputPrometheusRwMode$inboundSchema: z.ZodType<
   InputPrometheusRwMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwMode);
 /** @internal */
 export const InputPrometheusRwMode$outboundSchema: z.ZodType<
-  InputPrometheusRwMode,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwMode
-> = z.union([
-  z.nativeEnum(InputPrometheusRwMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwMode);
 
 /** @internal */
 export const InputPrometheusRwCompression$inboundSchema: z.ZodType<
   InputPrometheusRwCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwCompression);
 /** @internal */
 export const InputPrometheusRwCompression$outboundSchema: z.ZodType<
-  InputPrometheusRwCompression,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwCompression
-> = z.union([
-  z.nativeEnum(InputPrometheusRwCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwCompression);
 
 /** @internal */
 export const InputPrometheusRwPqControls$inboundSchema: z.ZodType<
@@ -542,40 +510,26 @@ export const InputPrometheusRwMinimumTLSVersion$inboundSchema: z.ZodType<
   InputPrometheusRwMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwMinimumTLSVersion);
 /** @internal */
 export const InputPrometheusRwMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputPrometheusRwMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputPrometheusRwMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwMinimumTLSVersion);
 
 /** @internal */
 export const InputPrometheusRwMaximumTLSVersion$inboundSchema: z.ZodType<
   InputPrometheusRwMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwMaximumTLSVersion);
 /** @internal */
 export const InputPrometheusRwMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputPrometheusRwMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputPrometheusRwMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwMaximumTLSVersion);
 
 /** @internal */
 export const InputPrometheusRwTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -655,20 +609,13 @@ export const InputPrometheusRwAuthenticationType$inboundSchema: z.ZodType<
   InputPrometheusRwAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputPrometheusRwAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputPrometheusRwAuthenticationType);
 /** @internal */
 export const InputPrometheusRwAuthenticationType$outboundSchema: z.ZodType<
-  InputPrometheusRwAuthenticationType,
+  string,
   z.ZodTypeDef,
   InputPrometheusRwAuthenticationType
-> = z.union([
-  z.nativeEnum(InputPrometheusRwAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputPrometheusRwAuthenticationType);
 
 /** @internal */
 export const InputPrometheusRwMetadatum$inboundSchema: z.ZodType<
@@ -807,7 +754,7 @@ export const InputPrometheusRw$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputPrometheusRwType$inboundSchema,
+  type: z.literal("prometheus_rw"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -857,7 +804,7 @@ export const InputPrometheusRw$inboundSchema: z.ZodType<
 /** @internal */
 export type InputPrometheusRw$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "prometheus_rw";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -906,7 +853,7 @@ export const InputPrometheusRw$outboundSchema: z.ZodType<
   InputPrometheusRw
 > = z.object({
   id: z.string().optional(),
-  type: InputPrometheusRwType$outboundSchema,
+  type: z.literal("prometheus_rw"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputrawudp.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 InputRawUdpType = {
-  RawUdp: "raw_udp",
-} as const;
-export type InputRawUdpType = ClosedEnum<typeof InputRawUdpType>;
-
 export type InputRawUdpConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -106,7 +97,7 @@ export type InputRawUdp = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputRawUdpType;
+  type: "raw_udp";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -168,15 +159,6 @@ export type InputRawUdp = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputRawUdpType$inboundSchema: z.ZodNativeEnum<
-  typeof InputRawUdpType
-> = z.nativeEnum(InputRawUdpType);
-/** @internal */
-export const InputRawUdpType$outboundSchema: z.ZodNativeEnum<
-  typeof InputRawUdpType
-> = InputRawUdpType$inboundSchema;
-
 /** @internal */
 export const InputRawUdpConnection$inboundSchema: z.ZodType<
   InputRawUdpConnection,
@@ -224,40 +206,26 @@ export const InputRawUdpMode$inboundSchema: z.ZodType<
   InputRawUdpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputRawUdpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputRawUdpMode);
 /** @internal */
 export const InputRawUdpMode$outboundSchema: z.ZodType<
-  InputRawUdpMode,
+  string,
   z.ZodTypeDef,
   InputRawUdpMode
-> = z.union([
-  z.nativeEnum(InputRawUdpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputRawUdpMode);
 
 /** @internal */
 export const InputRawUdpCompression$inboundSchema: z.ZodType<
   InputRawUdpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputRawUdpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputRawUdpCompression);
 /** @internal */
 export const InputRawUdpCompression$outboundSchema: z.ZodType<
-  InputRawUdpCompression,
+  string,
   z.ZodTypeDef,
   InputRawUdpCompression
-> = z.union([
-  z.nativeEnum(InputRawUdpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputRawUdpCompression);
 
 /** @internal */
 export const InputRawUdpPqControls$inboundSchema: z.ZodType<
@@ -397,7 +365,7 @@ export const InputRawUdp$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputRawUdpType$inboundSchema,
+  type: z.literal("raw_udp"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -421,7 +389,7 @@ export const InputRawUdp$inboundSchema: z.ZodType<
 /** @internal */
 export type InputRawUdp$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "raw_udp";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -448,7 +416,7 @@ export const InputRawUdp$outboundSchema: z.ZodType<
   InputRawUdp
 > = z.object({
   id: z.string().optional(),
-  type: InputRawUdpType$outboundSchema,
+  type: z.literal("raw_udp"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),