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

package/src/models/inputsystemmetrics.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 InputSystemMetricsType = {
-  SystemMetrics: "system_metrics",
-} as const;
-export type InputSystemMetricsType = ClosedEnum<typeof InputSystemMetricsType>;
-
 export type InputSystemMetricsConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -495,7 +486,7 @@ export type InputSystemMetrics = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputSystemMetricsType;
+  type: "system_metrics";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -537,15 +528,6 @@ export type InputSystemMetrics = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputSystemMetricsType$inboundSchema: z.ZodNativeEnum<
-  typeof InputSystemMetricsType
-> = z.nativeEnum(InputSystemMetricsType);
-/** @internal */
-export const InputSystemMetricsType$outboundSchema: z.ZodNativeEnum<
-  typeof InputSystemMetricsType
-> = InputSystemMetricsType$inboundSchema;
-
 /** @internal */
 export const InputSystemMetricsConnection$inboundSchema: z.ZodType<
   InputSystemMetricsConnection,
@@ -595,40 +577,26 @@ export const InputSystemMetricsPqMode$inboundSchema: z.ZodType<
   InputSystemMetricsPqMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsPqMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsPqMode);
 /** @internal */
 export const InputSystemMetricsPqMode$outboundSchema: z.ZodType<
-  InputSystemMetricsPqMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsPqMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsPqMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsPqMode);
 
 /** @internal */
 export const InputSystemMetricsCompression$inboundSchema: z.ZodType<
   InputSystemMetricsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsCompression);
 /** @internal */
 export const InputSystemMetricsCompression$outboundSchema: z.ZodType<
-  InputSystemMetricsCompression,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsCompression
-> = z.union([
-  z.nativeEnum(InputSystemMetricsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsCompression);
 
 /** @internal */
 export const InputSystemMetricsPqControls$inboundSchema: z.ZodType<
@@ -732,40 +700,26 @@ export const InputSystemMetricsHostMode$inboundSchema: z.ZodType<
   InputSystemMetricsHostMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsHostMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsHostMode);
 /** @internal */
 export const InputSystemMetricsHostMode$outboundSchema: z.ZodType<
-  InputSystemMetricsHostMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsHostMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsHostMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsHostMode);
 
 /** @internal */
 export const InputSystemMetricsSystemMode$inboundSchema: z.ZodType<
   InputSystemMetricsSystemMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsSystemMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsSystemMode);
 /** @internal */
 export const InputSystemMetricsSystemMode$outboundSchema: z.ZodType<
-  InputSystemMetricsSystemMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsSystemMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsSystemMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsSystemMode);
 
 /** @internal */
 export const InputSystemMetricsSystem$inboundSchema: z.ZodType<
@@ -814,20 +768,13 @@ export const InputSystemMetricsCpuMode$inboundSchema: z.ZodType<
   InputSystemMetricsCpuMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsCpuMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsCpuMode);
 /** @internal */
 export const InputSystemMetricsCpuMode$outboundSchema: z.ZodType<
-  InputSystemMetricsCpuMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsCpuMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsCpuMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsCpuMode);
 
 /** @internal */
 export const InputSystemMetricsCpu$inboundSchema: z.ZodType<
@@ -882,20 +829,13 @@ export const InputSystemMetricsMemoryMode$inboundSchema: z.ZodType<
   InputSystemMetricsMemoryMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsMemoryMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsMemoryMode);
 /** @internal */
 export const InputSystemMetricsMemoryMode$outboundSchema: z.ZodType<
-  InputSystemMetricsMemoryMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsMemoryMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsMemoryMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsMemoryMode);
 
 /** @internal */
 export const InputSystemMetricsMemory$inboundSchema: z.ZodType<
@@ -944,20 +884,13 @@ export const InputSystemMetricsNetworkMode$inboundSchema: z.ZodType<
   InputSystemMetricsNetworkMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsNetworkMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsNetworkMode);
 /** @internal */
 export const InputSystemMetricsNetworkMode$outboundSchema: z.ZodType<
-  InputSystemMetricsNetworkMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsNetworkMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsNetworkMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsNetworkMode);
 
 /** @internal */
 export const InputSystemMetricsNetwork$inboundSchema: z.ZodType<
@@ -1015,20 +948,13 @@ export const InputSystemMetricsDiskMode$inboundSchema: z.ZodType<
   InputSystemMetricsDiskMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsDiskMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsDiskMode);
 /** @internal */
 export const InputSystemMetricsDiskMode$outboundSchema: z.ZodType<
-  InputSystemMetricsDiskMode,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsDiskMode
-> = z.union([
-  z.nativeEnum(InputSystemMetricsDiskMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsDiskMode);
 
 /** @internal */
 export const InputSystemMetricsDisk$inboundSchema: z.ZodType<
@@ -1269,20 +1195,13 @@ export const ContainerMode$inboundSchema: z.ZodType<
   ContainerMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(ContainerMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(ContainerMode);
 /** @internal */
 export const ContainerMode$outboundSchema: z.ZodType<
-  ContainerMode,
+  string,
   z.ZodTypeDef,
   ContainerMode
-> = z.union([
-  z.nativeEnum(ContainerMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ContainerMode);
 
 /** @internal */
 export const InputSystemMetricsFilter$inboundSchema: z.ZodType<
@@ -1427,20 +1346,13 @@ export const InputSystemMetricsDataCompressionFormat$inboundSchema: z.ZodType<
   InputSystemMetricsDataCompressionFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemMetricsDataCompressionFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemMetricsDataCompressionFormat);
 /** @internal */
 export const InputSystemMetricsDataCompressionFormat$outboundSchema: z.ZodType<
-  InputSystemMetricsDataCompressionFormat,
+  string,
   z.ZodTypeDef,
   InputSystemMetricsDataCompressionFormat
-> = z.union([
-  z.nativeEnum(InputSystemMetricsDataCompressionFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemMetricsDataCompressionFormat);
 
 /** @internal */
 export const InputSystemMetricsPersistence$inboundSchema: z.ZodType<
@@ -1509,7 +1421,7 @@ export const InputSystemMetrics$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputSystemMetricsType$inboundSchema,
+  type: z.literal("system_metrics"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -1532,7 +1444,7 @@ export const InputSystemMetrics$inboundSchema: z.ZodType<
 /** @internal */
 export type InputSystemMetrics$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "system_metrics";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -1557,7 +1469,7 @@ export const InputSystemMetrics$outboundSchema: z.ZodType<
   InputSystemMetrics
 > = z.object({
   id: z.string().optional(),
-  type: InputSystemMetricsType$outboundSchema,
+  type: z.literal("system_metrics"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputsystemstate.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 InputSystemStateType = {
-  SystemState: "system_state",
-} as const;
-export type InputSystemStateType = ClosedEnum<typeof InputSystemStateType>;
-
 export type InputSystemStateConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -264,7 +255,7 @@ export type InputSystemState = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputSystemStateType;
+  type: "system_state";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -308,15 +299,6 @@ export type InputSystemState = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputSystemStateType$inboundSchema: z.ZodNativeEnum<
-  typeof InputSystemStateType
-> = z.nativeEnum(InputSystemStateType);
-/** @internal */
-export const InputSystemStateType$outboundSchema: z.ZodNativeEnum<
-  typeof InputSystemStateType
-> = InputSystemStateType$inboundSchema;
-
 /** @internal */
 export const InputSystemStateConnection$inboundSchema: z.ZodType<
   InputSystemStateConnection,
@@ -364,40 +346,26 @@ export const InputSystemStateMode$inboundSchema: z.ZodType<
   InputSystemStateMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemStateMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemStateMode);
 /** @internal */
 export const InputSystemStateMode$outboundSchema: z.ZodType<
-  InputSystemStateMode,
+  string,
   z.ZodTypeDef,
   InputSystemStateMode
-> = z.union([
-  z.nativeEnum(InputSystemStateMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemStateMode);
 
 /** @internal */
 export const InputSystemStateCompression$inboundSchema: z.ZodType<
   InputSystemStateCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemStateCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemStateCompression);
 /** @internal */
 export const InputSystemStateCompression$outboundSchema: z.ZodType<
-  InputSystemStateCompression,
+  string,
   z.ZodTypeDef,
   InputSystemStateCompression
-> = z.union([
-  z.nativeEnum(InputSystemStateCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemStateCompression);
 
 /** @internal */
 export const InputSystemStatePqControls$inboundSchema: z.ZodType<
@@ -992,20 +960,13 @@ export const InputSystemStateDataCompressionFormat$inboundSchema: z.ZodType<
   InputSystemStateDataCompressionFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSystemStateDataCompressionFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSystemStateDataCompressionFormat);
 /** @internal */
 export const InputSystemStateDataCompressionFormat$outboundSchema: z.ZodType<
-  InputSystemStateDataCompressionFormat,
+  string,
   z.ZodTypeDef,
   InputSystemStateDataCompressionFormat
-> = z.union([
-  z.nativeEnum(InputSystemStateDataCompressionFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSystemStateDataCompressionFormat);
 
 /** @internal */
 export const InputSystemStatePersistence$inboundSchema: z.ZodType<
@@ -1072,7 +1033,7 @@ export const InputSystemState$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputSystemStateType$inboundSchema,
+  type: z.literal("system_state"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -1094,7 +1055,7 @@ export const InputSystemState$inboundSchema: z.ZodType<
 /** @internal */
 export type InputSystemState$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "system_state";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -1118,7 +1079,7 @@ export const InputSystemState$outboundSchema: z.ZodType<
   InputSystemState
 > = z.object({
   id: z.string().optional(),
-  type: InputSystemStateType$outboundSchema,
+  type: z.literal("system_state"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputtcp.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 InputTcpType = {
-  Tcp: "tcp",
-} as const;
-export type InputTcpType = ClosedEnum<typeof InputTcpType>;
-
 export type InputTcpConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -190,7 +181,7 @@ export type InputTcp = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputTcpType;
+  type: "tcp";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -282,13 +273,6 @@ export type InputTcp = {
   textSecret?: string | undefined;
 };
 
-/** @internal */
-export const InputTcpType$inboundSchema: z.ZodNativeEnum<typeof InputTcpType> =
-  z.nativeEnum(InputTcpType);
-/** @internal */
-export const InputTcpType$outboundSchema: z.ZodNativeEnum<typeof InputTcpType> =
-  InputTcpType$inboundSchema;
-
 /** @internal */
 export const InputTcpConnection$inboundSchema: z.ZodType<
   InputTcpConnection,
@@ -336,40 +320,26 @@ export const InputTcpMode$inboundSchema: z.ZodType<
   InputTcpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpMode);
 /** @internal */
 export const InputTcpMode$outboundSchema: z.ZodType<
-  InputTcpMode,
+  string,
   z.ZodTypeDef,
   InputTcpMode
-> = z.union([
-  z.nativeEnum(InputTcpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpMode);
 
 /** @internal */
 export const InputTcpCompression$inboundSchema: z.ZodType<
   InputTcpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpCompression);
 /** @internal */
 export const InputTcpCompression$outboundSchema: z.ZodType<
-  InputTcpCompression,
+  string,
   z.ZodTypeDef,
   InputTcpCompression
-> = z.union([
-  z.nativeEnum(InputTcpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpCompression);
 
 /** @internal */
 export const InputTcpPqControls$inboundSchema: z.ZodType<
@@ -465,40 +435,26 @@ export const InputTcpMinimumTLSVersion$inboundSchema: z.ZodType<
   InputTcpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpMinimumTLSVersion);
 /** @internal */
 export const InputTcpMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputTcpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputTcpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputTcpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpMinimumTLSVersion);
 
 /** @internal */
 export const InputTcpMaximumTLSVersion$inboundSchema: z.ZodType<
   InputTcpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpMaximumTLSVersion);
 /** @internal */
 export const InputTcpMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputTcpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputTcpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputTcpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpMaximumTLSVersion);
 
 /** @internal */
 export const InputTcpTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -663,20 +619,13 @@ export const InputTcpAuthenticationMethod$inboundSchema: z.ZodType<
   InputTcpAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputTcpAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputTcpAuthenticationMethod);
 /** @internal */
 export const InputTcpAuthenticationMethod$outboundSchema: z.ZodType<
-  InputTcpAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputTcpAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputTcpAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputTcpAuthenticationMethod);
 
 /** @internal */
 export const InputTcp$inboundSchema: z.ZodType<
@@ -685,7 +634,7 @@ export const InputTcp$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputTcpType$inboundSchema,
+  type: z.literal("tcp"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -717,7 +666,7 @@ export const InputTcp$inboundSchema: z.ZodType<
 /** @internal */
 export type InputTcp$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "tcp";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -753,7 +702,7 @@ export const InputTcp$outboundSchema: z.ZodType<
   InputTcp
 > = z.object({
   id: z.string().optional(),
-  type: InputTcpType$outboundSchema,
+  type: z.literal("tcp"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),