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

package/src/models/outputnewrelic.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 OutputNewrelicType = {
-  Newrelic: "newrelic",
-} as const;
-export type OutputNewrelicType = ClosedEnum<typeof OutputNewrelicType>;
-
 /**
  * Which New Relic region endpoint to use.
  */
@@ -227,7 +218,7 @@ export type OutputNewrelic = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputNewrelicType;
+  type: "newrelic";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -382,54 +373,31 @@ export type OutputNewrelic = {
   textSecret?: string | undefined;
 };
 
-/** @internal */
-export const OutputNewrelicType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputNewrelicType
-> = z.nativeEnum(OutputNewrelicType);
-/** @internal */
-export const OutputNewrelicType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputNewrelicType
-> = OutputNewrelicType$inboundSchema;
-
 /** @internal */
 export const OutputNewrelicRegion$inboundSchema: z.ZodType<
   OutputNewrelicRegion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicRegion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicRegion);
 /** @internal */
 export const OutputNewrelicRegion$outboundSchema: z.ZodType<
-  OutputNewrelicRegion,
+  string,
   z.ZodTypeDef,
   OutputNewrelicRegion
-> = z.union([
-  z.nativeEnum(OutputNewrelicRegion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicRegion);
 
 /** @internal */
 export const FieldName$inboundSchema: z.ZodType<
   FieldName,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(FieldName),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(FieldName);
 /** @internal */
 export const FieldName$outboundSchema: z.ZodType<
-  FieldName,
+  string,
   z.ZodTypeDef,
   FieldName
-> = z.union([
-  z.nativeEnum(FieldName),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(FieldName);
 
 /** @internal */
 export const OutputNewrelicMetadatum$inboundSchema: z.ZodType<
@@ -522,20 +490,13 @@ export const OutputNewrelicFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputNewrelicFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicFailedRequestLoggingMode);
 /** @internal */
 export const OutputNewrelicFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputNewrelicFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputNewrelicFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputNewrelicFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputNewrelicResponseRetrySetting$inboundSchema: z.ZodType<
@@ -644,100 +605,65 @@ export const OutputNewrelicBackpressureBehavior$inboundSchema: z.ZodType<
   OutputNewrelicBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicBackpressureBehavior);
 /** @internal */
 export const OutputNewrelicBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicBackpressureBehavior);
 
 /** @internal */
 export const OutputNewrelicAuthenticationMethod$inboundSchema: z.ZodType<
   OutputNewrelicAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicAuthenticationMethod);
 /** @internal */
 export const OutputNewrelicAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputNewrelicAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputNewrelicAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputNewrelicAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicAuthenticationMethod);
 
 /** @internal */
 export const OutputNewrelicMode$inboundSchema: z.ZodType<
   OutputNewrelicMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicMode);
 /** @internal */
 export const OutputNewrelicMode$outboundSchema: z.ZodType<
-  OutputNewrelicMode,
+  string,
   z.ZodTypeDef,
   OutputNewrelicMode
-> = z.union([
-  z.nativeEnum(OutputNewrelicMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicMode);
 
 /** @internal */
 export const OutputNewrelicCompression$inboundSchema: z.ZodType<
   OutputNewrelicCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicCompression);
 /** @internal */
 export const OutputNewrelicCompression$outboundSchema: z.ZodType<
-  OutputNewrelicCompression,
+  string,
   z.ZodTypeDef,
   OutputNewrelicCompression
-> = z.union([
-  z.nativeEnum(OutputNewrelicCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicCompression);
 
 /** @internal */
 export const OutputNewrelicQueueFullBehavior$inboundSchema: z.ZodType<
   OutputNewrelicQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicQueueFullBehavior);
 /** @internal */
 export const OutputNewrelicQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicQueueFullBehavior);
 
 /** @internal */
 export const OutputNewrelicPqControls$inboundSchema: z.ZodType<
@@ -779,7 +705,7 @@ export const OutputNewrelic$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputNewrelicType$inboundSchema,
+  type: z.literal("newrelic"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -836,7 +762,7 @@ export const OutputNewrelic$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputNewrelic$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "newrelic";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -890,7 +816,7 @@ export const OutputNewrelic$outboundSchema: z.ZodType<
   OutputNewrelic
 > = z.object({
   id: z.string().optional(),
-  type: OutputNewrelicType$outboundSchema,
+  type: z.literal("newrelic"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputnewrelicevents.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 OutputNewrelicEventsType = {
-  NewrelicEvents: "newrelic_events",
-} as const;
-export type OutputNewrelicEventsType = ClosedEnum<
-  typeof OutputNewrelicEventsType
->;
-
 /**
  * Which New Relic region endpoint to use.
  */
@@ -217,7 +206,7 @@ export type OutputNewrelicEvents = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputNewrelicEventsType;
+  type: "newrelic_events";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -368,34 +357,18 @@ export type OutputNewrelicEvents = {
   textSecret?: string | undefined;
 };
 
-/** @internal */
-export const OutputNewrelicEventsType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputNewrelicEventsType
-> = z.nativeEnum(OutputNewrelicEventsType);
-/** @internal */
-export const OutputNewrelicEventsType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputNewrelicEventsType
-> = OutputNewrelicEventsType$inboundSchema;
-
 /** @internal */
 export const OutputNewrelicEventsRegion$inboundSchema: z.ZodType<
   OutputNewrelicEventsRegion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsRegion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsRegion);
 /** @internal */
 export const OutputNewrelicEventsRegion$outboundSchema: z.ZodType<
-  OutputNewrelicEventsRegion,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsRegion
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsRegion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsRegion);
 
 /** @internal */
 export const OutputNewrelicEventsExtraHttpHeader$inboundSchema: z.ZodType<
@@ -448,21 +421,14 @@ export const OutputNewrelicEventsFailedRequestLoggingMode$inboundSchema:
     OutputNewrelicEventsFailedRequestLoggingMode,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(OutputNewrelicEventsFailedRequestLoggingMode),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(OutputNewrelicEventsFailedRequestLoggingMode);
 /** @internal */
 export const OutputNewrelicEventsFailedRequestLoggingMode$outboundSchema:
   z.ZodType<
-    OutputNewrelicEventsFailedRequestLoggingMode,
+    string,
     z.ZodTypeDef,
     OutputNewrelicEventsFailedRequestLoggingMode
-  > = z.union([
-    z.nativeEnum(OutputNewrelicEventsFailedRequestLoggingMode),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(OutputNewrelicEventsFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputNewrelicEventsResponseRetrySetting$inboundSchema: z.ZodType<
@@ -583,100 +549,65 @@ export const OutputNewrelicEventsBackpressureBehavior$inboundSchema: z.ZodType<
   OutputNewrelicEventsBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsBackpressureBehavior);
 /** @internal */
 export const OutputNewrelicEventsBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicEventsBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsBackpressureBehavior);
 
 /** @internal */
 export const OutputNewrelicEventsAuthenticationMethod$inboundSchema: z.ZodType<
   OutputNewrelicEventsAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsAuthenticationMethod);
 /** @internal */
 export const OutputNewrelicEventsAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputNewrelicEventsAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsAuthenticationMethod);
 
 /** @internal */
 export const OutputNewrelicEventsMode$inboundSchema: z.ZodType<
   OutputNewrelicEventsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsMode);
 /** @internal */
 export const OutputNewrelicEventsMode$outboundSchema: z.ZodType<
-  OutputNewrelicEventsMode,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsMode
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsMode);
 
 /** @internal */
 export const OutputNewrelicEventsCompression$inboundSchema: z.ZodType<
   OutputNewrelicEventsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsCompression);
 /** @internal */
 export const OutputNewrelicEventsCompression$outboundSchema: z.ZodType<
-  OutputNewrelicEventsCompression,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsCompression
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsCompression);
 
 /** @internal */
 export const OutputNewrelicEventsQueueFullBehavior$inboundSchema: z.ZodType<
   OutputNewrelicEventsQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputNewrelicEventsQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputNewrelicEventsQueueFullBehavior);
 /** @internal */
 export const OutputNewrelicEventsQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputNewrelicEventsQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputNewrelicEventsQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputNewrelicEventsQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputNewrelicEventsQueueFullBehavior);
 
 /** @internal */
 export const OutputNewrelicEventsPqControls$inboundSchema: z.ZodType<
@@ -720,7 +651,7 @@ export const OutputNewrelicEvents$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputNewrelicEventsType$inboundSchema,
+  type: z.literal("newrelic_events"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -776,7 +707,7 @@ export const OutputNewrelicEvents$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputNewrelicEvents$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "newrelic_events";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -830,7 +761,7 @@ export const OutputNewrelicEvents$outboundSchema: z.ZodType<
   OutputNewrelicEvents
 > = z.object({
   id: z.string().optional(),
-  type: OutputNewrelicEventsType$outboundSchema,
+  type: z.literal("newrelic_events"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),