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

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

package/src/models/outputhoneycomb.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 OutputHoneycombType = {
-  Honeycomb: "honeycomb",
-} as const;
-export type OutputHoneycombType = ClosedEnum<typeof OutputHoneycombType>;
-
 export type OutputHoneycombExtraHttpHeader = {
   name?: string | undefined;
   value: string;
@@ -189,7 +180,7 @@ export type OutputHoneycomb = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputHoneycombType;
+  type: "honeycomb";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -331,15 +322,6 @@ export type OutputHoneycomb = {
   textSecret?: string | undefined;
 };
 
-/** @internal */
-export const OutputHoneycombType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputHoneycombType
-> = z.nativeEnum(OutputHoneycombType);
-/** @internal */
-export const OutputHoneycombType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputHoneycombType
-> = OutputHoneycombType$inboundSchema;
-
 /** @internal */
 export const OutputHoneycombExtraHttpHeader$inboundSchema: z.ZodType<
   OutputHoneycombExtraHttpHeader,
@@ -389,20 +371,13 @@ export const OutputHoneycombFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputHoneycombFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHoneycombFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHoneycombFailedRequestLoggingMode);
 /** @internal */
 export const OutputHoneycombFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputHoneycombFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputHoneycombFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputHoneycombFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHoneycombFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputHoneycombResponseRetrySetting$inboundSchema: z.ZodType<
@@ -511,100 +486,65 @@ export const OutputHoneycombBackpressureBehavior$inboundSchema: z.ZodType<
   OutputHoneycombBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHoneycombBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHoneycombBackpressureBehavior);
 /** @internal */
 export const OutputHoneycombBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputHoneycombBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputHoneycombBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputHoneycombBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHoneycombBackpressureBehavior);
 
 /** @internal */
 export const OutputHoneycombAuthenticationMethod$inboundSchema: z.ZodType<
   OutputHoneycombAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHoneycombAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHoneycombAuthenticationMethod);
 /** @internal */
 export const OutputHoneycombAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputHoneycombAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputHoneycombAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputHoneycombAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHoneycombAuthenticationMethod);
 
 /** @internal */
 export const OutputHoneycombMode$inboundSchema: z.ZodType<
   OutputHoneycombMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHoneycombMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHoneycombMode);
 /** @internal */
 export const OutputHoneycombMode$outboundSchema: z.ZodType<
-  OutputHoneycombMode,
+  string,
   z.ZodTypeDef,
   OutputHoneycombMode
-> = z.union([
-  z.nativeEnum(OutputHoneycombMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHoneycombMode);
 
 /** @internal */
 export const OutputHoneycombCompression$inboundSchema: z.ZodType<
   OutputHoneycombCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHoneycombCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHoneycombCompression);
 /** @internal */
 export const OutputHoneycombCompression$outboundSchema: z.ZodType<
-  OutputHoneycombCompression,
+  string,
   z.ZodTypeDef,
   OutputHoneycombCompression
-> = z.union([
-  z.nativeEnum(OutputHoneycombCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHoneycombCompression);
 
 /** @internal */
 export const OutputHoneycombQueueFullBehavior$inboundSchema: z.ZodType<
   OutputHoneycombQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHoneycombQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHoneycombQueueFullBehavior);
 /** @internal */
 export const OutputHoneycombQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputHoneycombQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputHoneycombQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputHoneycombQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHoneycombQueueFullBehavior);
 
 /** @internal */
 export const OutputHoneycombPqControls$inboundSchema: z.ZodType<
@@ -646,7 +586,7 @@ export const OutputHoneycomb$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputHoneycombType$inboundSchema,
+  type: z.literal("honeycomb"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -697,7 +637,7 @@ export const OutputHoneycomb$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputHoneycomb$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "honeycomb";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -746,7 +686,7 @@ export const OutputHoneycomb$outboundSchema: z.ZodType<
   OutputHoneycomb
 > = z.object({
   id: z.string().optional(),
-  type: OutputHoneycombType$outboundSchema,
+  type: z.literal("honeycomb"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),

package/src/models/outputhumiohec.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 OutputHumioHecType = {
-  HumioHec: "humio_hec",
-} as const;
-export type OutputHumioHecType = ClosedEnum<typeof OutputHumioHecType>;
-
 export type OutputHumioHecExtraHttpHeader = {
   name?: string | undefined;
   value: string;
@@ -209,7 +200,7 @@ export type OutputHumioHec = {
    * Unique ID for this output
    */
   id?: string | undefined;
-  type: OutputHumioHecType;
+  type: "humio_hec";
   /**
    * Pipeline to process data before sending out to this output
    */
@@ -351,15 +342,6 @@ export type OutputHumioHec = {
   pqControls?: OutputHumioHecPqControls | undefined;
 };
 
-/** @internal */
-export const OutputHumioHecType$inboundSchema: z.ZodNativeEnum<
-  typeof OutputHumioHecType
-> = z.nativeEnum(OutputHumioHecType);
-/** @internal */
-export const OutputHumioHecType$outboundSchema: z.ZodNativeEnum<
-  typeof OutputHumioHecType
-> = OutputHumioHecType$inboundSchema;
-
 /** @internal */
 export const OutputHumioHecExtraHttpHeader$inboundSchema: z.ZodType<
   OutputHumioHecExtraHttpHeader,
@@ -409,60 +391,39 @@ export const OutputHumioHecFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputHumioHecFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecFailedRequestLoggingMode);
 /** @internal */
 export const OutputHumioHecFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputHumioHecFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputHumioHecFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputHumioHecFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputHumioHecRequestFormat$inboundSchema: z.ZodType<
   OutputHumioHecRequestFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecRequestFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecRequestFormat);
 /** @internal */
 export const OutputHumioHecRequestFormat$outboundSchema: z.ZodType<
-  OutputHumioHecRequestFormat,
+  string,
   z.ZodTypeDef,
   OutputHumioHecRequestFormat
-> = z.union([
-  z.nativeEnum(OutputHumioHecRequestFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecRequestFormat);
 
 /** @internal */
 export const OutputHumioHecAuthenticationMethod$inboundSchema: z.ZodType<
   OutputHumioHecAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecAuthenticationMethod);
 /** @internal */
 export const OutputHumioHecAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputHumioHecAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputHumioHecAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputHumioHecAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecAuthenticationMethod);
 
 /** @internal */
 export const OutputHumioHecResponseRetrySetting$inboundSchema: z.ZodType<
@@ -571,80 +532,52 @@ export const OutputHumioHecBackpressureBehavior$inboundSchema: z.ZodType<
   OutputHumioHecBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecBackpressureBehavior);
 /** @internal */
 export const OutputHumioHecBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputHumioHecBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputHumioHecBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputHumioHecBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecBackpressureBehavior);
 
 /** @internal */
 export const OutputHumioHecMode$inboundSchema: z.ZodType<
   OutputHumioHecMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecMode);
 /** @internal */
 export const OutputHumioHecMode$outboundSchema: z.ZodType<
-  OutputHumioHecMode,
+  string,
   z.ZodTypeDef,
   OutputHumioHecMode
-> = z.union([
-  z.nativeEnum(OutputHumioHecMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecMode);
 
 /** @internal */
 export const OutputHumioHecCompression$inboundSchema: z.ZodType<
   OutputHumioHecCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecCompression);
 /** @internal */
 export const OutputHumioHecCompression$outboundSchema: z.ZodType<
-  OutputHumioHecCompression,
+  string,
   z.ZodTypeDef,
   OutputHumioHecCompression
-> = z.union([
-  z.nativeEnum(OutputHumioHecCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecCompression);
 
 /** @internal */
 export const OutputHumioHecQueueFullBehavior$inboundSchema: z.ZodType<
   OutputHumioHecQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputHumioHecQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputHumioHecQueueFullBehavior);
 /** @internal */
 export const OutputHumioHecQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputHumioHecQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputHumioHecQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputHumioHecQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputHumioHecQueueFullBehavior);
 
 /** @internal */
 export const OutputHumioHecPqControls$inboundSchema: z.ZodType<
@@ -686,7 +619,7 @@ export const OutputHumioHec$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: OutputHumioHecType$inboundSchema,
+  type: z.literal("humio_hec"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),
@@ -738,7 +671,7 @@ export const OutputHumioHec$inboundSchema: z.ZodType<
 /** @internal */
 export type OutputHumioHec$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "humio_hec";
   pipeline?: string | undefined;
   systemFields?: Array<string> | undefined;
   environment?: string | undefined;
@@ -788,7 +721,7 @@ export const OutputHumioHec$outboundSchema: z.ZodType<
   OutputHumioHec
 > = z.object({
   id: z.string().optional(),
-  type: OutputHumioHecType$outboundSchema,
+  type: z.literal("humio_hec"),
   pipeline: z.string().optional(),
   systemFields: z.array(z.string()).optional(),
   environment: z.string().optional(),