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

package/src/models/inputgrafana.ts

@@ -4,12 +4,8 @@
 
 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 { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -943,40 +939,26 @@ export const InputGrafanaMode2$inboundSchema: z.ZodType<
   InputGrafanaMode2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaMode2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaMode2);
 /** @internal */
 export const InputGrafanaMode2$outboundSchema: z.ZodType<
-  InputGrafanaMode2,
+  string,
   z.ZodTypeDef,
   InputGrafanaMode2
-> = z.union([
-  z.nativeEnum(InputGrafanaMode2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaMode2);
 
 /** @internal */
 export const InputGrafanaCompression2$inboundSchema: z.ZodType<
   InputGrafanaCompression2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaCompression2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaCompression2);
 /** @internal */
 export const InputGrafanaCompression2$outboundSchema: z.ZodType<
-  InputGrafanaCompression2,
+  string,
   z.ZodTypeDef,
   InputGrafanaCompression2
-> = z.union([
-  z.nativeEnum(InputGrafanaCompression2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaCompression2);
 
 /** @internal */
 export const InputGrafanaPqControls2$inboundSchema: z.ZodType<
@@ -1074,40 +1056,26 @@ export const InputGrafanaMinimumTLSVersion2$inboundSchema: z.ZodType<
   InputGrafanaMinimumTLSVersion2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaMinimumTLSVersion2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaMinimumTLSVersion2);
 /** @internal */
 export const InputGrafanaMinimumTLSVersion2$outboundSchema: z.ZodType<
-  InputGrafanaMinimumTLSVersion2,
+  string,
   z.ZodTypeDef,
   InputGrafanaMinimumTLSVersion2
-> = z.union([
-  z.nativeEnum(InputGrafanaMinimumTLSVersion2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaMinimumTLSVersion2);
 
 /** @internal */
 export const InputGrafanaMaximumTLSVersion2$inboundSchema: z.ZodType<
   InputGrafanaMaximumTLSVersion2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaMaximumTLSVersion2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaMaximumTLSVersion2);
 /** @internal */
 export const InputGrafanaMaximumTLSVersion2$outboundSchema: z.ZodType<
-  InputGrafanaMaximumTLSVersion2,
+  string,
   z.ZodTypeDef,
   InputGrafanaMaximumTLSVersion2
-> = z.union([
-  z.nativeEnum(InputGrafanaMaximumTLSVersion2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaMaximumTLSVersion2);
 
 /** @internal */
 export const InputGrafanaTLSSettingsServerSide2$inboundSchema: z.ZodType<
@@ -1187,21 +1155,14 @@ export const InputGrafanaPrometheusAuthAuthenticationType2$inboundSchema:
     InputGrafanaPrometheusAuthAuthenticationType2,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputGrafanaPrometheusAuthAuthenticationType2),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputGrafanaPrometheusAuthAuthenticationType2);
 /** @internal */
 export const InputGrafanaPrometheusAuthAuthenticationType2$outboundSchema:
   z.ZodType<
-    InputGrafanaPrometheusAuthAuthenticationType2,
+    string,
     z.ZodTypeDef,
     InputGrafanaPrometheusAuthAuthenticationType2
-  > = z.union([
-    z.nativeEnum(InputGrafanaPrometheusAuthAuthenticationType2),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(InputGrafanaPrometheusAuthAuthenticationType2);
 
 /** @internal */
 export const PrometheusAuthOauthParam2$inboundSchema: z.ZodType<
@@ -1379,20 +1340,13 @@ export const InputGrafanaLokiAuthAuthenticationType2$inboundSchema: z.ZodType<
   InputGrafanaLokiAuthAuthenticationType2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaLokiAuthAuthenticationType2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaLokiAuthAuthenticationType2);
 /** @internal */
 export const InputGrafanaLokiAuthAuthenticationType2$outboundSchema: z.ZodType<
-  InputGrafanaLokiAuthAuthenticationType2,
+  string,
   z.ZodTypeDef,
   InputGrafanaLokiAuthAuthenticationType2
-> = z.union([
-  z.nativeEnum(InputGrafanaLokiAuthAuthenticationType2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaLokiAuthAuthenticationType2);
 
 /** @internal */
 export const LokiAuthOauthParam2$inboundSchema: z.ZodType<
@@ -1796,40 +1750,26 @@ export const InputGrafanaMode1$inboundSchema: z.ZodType<
   InputGrafanaMode1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaMode1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaMode1);
 /** @internal */
 export const InputGrafanaMode1$outboundSchema: z.ZodType<
-  InputGrafanaMode1,
+  string,
   z.ZodTypeDef,
   InputGrafanaMode1
-> = z.union([
-  z.nativeEnum(InputGrafanaMode1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaMode1);
 
 /** @internal */
 export const InputGrafanaCompression1$inboundSchema: z.ZodType<
   InputGrafanaCompression1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaCompression1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaCompression1);
 /** @internal */
 export const InputGrafanaCompression1$outboundSchema: z.ZodType<
-  InputGrafanaCompression1,
+  string,
   z.ZodTypeDef,
   InputGrafanaCompression1
-> = z.union([
-  z.nativeEnum(InputGrafanaCompression1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaCompression1);
 
 /** @internal */
 export const InputGrafanaPqControls1$inboundSchema: z.ZodType<
@@ -1927,40 +1867,26 @@ export const InputGrafanaMinimumTLSVersion1$inboundSchema: z.ZodType<
   InputGrafanaMinimumTLSVersion1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaMinimumTLSVersion1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaMinimumTLSVersion1);
 /** @internal */
 export const InputGrafanaMinimumTLSVersion1$outboundSchema: z.ZodType<
-  InputGrafanaMinimumTLSVersion1,
+  string,
   z.ZodTypeDef,
   InputGrafanaMinimumTLSVersion1
-> = z.union([
-  z.nativeEnum(InputGrafanaMinimumTLSVersion1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaMinimumTLSVersion1);
 
 /** @internal */
 export const InputGrafanaMaximumTLSVersion1$inboundSchema: z.ZodType<
   InputGrafanaMaximumTLSVersion1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaMaximumTLSVersion1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaMaximumTLSVersion1);
 /** @internal */
 export const InputGrafanaMaximumTLSVersion1$outboundSchema: z.ZodType<
-  InputGrafanaMaximumTLSVersion1,
+  string,
   z.ZodTypeDef,
   InputGrafanaMaximumTLSVersion1
-> = z.union([
-  z.nativeEnum(InputGrafanaMaximumTLSVersion1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaMaximumTLSVersion1);
 
 /** @internal */
 export const InputGrafanaTLSSettingsServerSide1$inboundSchema: z.ZodType<
@@ -2040,21 +1966,14 @@ export const InputGrafanaPrometheusAuthAuthenticationType1$inboundSchema:
     InputGrafanaPrometheusAuthAuthenticationType1,
     z.ZodTypeDef,
     unknown
-  > = z
-    .union([
-      z.nativeEnum(InputGrafanaPrometheusAuthAuthenticationType1),
-      z.string().transform(catchUnrecognizedEnum),
-    ]);
+  > = openEnums.inboundSchema(InputGrafanaPrometheusAuthAuthenticationType1);
 /** @internal */
 export const InputGrafanaPrometheusAuthAuthenticationType1$outboundSchema:
   z.ZodType<
-    InputGrafanaPrometheusAuthAuthenticationType1,
+    string,
     z.ZodTypeDef,
     InputGrafanaPrometheusAuthAuthenticationType1
-  > = z.union([
-    z.nativeEnum(InputGrafanaPrometheusAuthAuthenticationType1),
-    z.string().and(z.custom<Unrecognized<string>>()),
-  ]);
+  > = openEnums.outboundSchema(InputGrafanaPrometheusAuthAuthenticationType1);
 
 /** @internal */
 export const PrometheusAuthOauthParam1$inboundSchema: z.ZodType<
@@ -2232,20 +2151,13 @@ export const InputGrafanaLokiAuthAuthenticationType1$inboundSchema: z.ZodType<
   InputGrafanaLokiAuthAuthenticationType1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputGrafanaLokiAuthAuthenticationType1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputGrafanaLokiAuthAuthenticationType1);
 /** @internal */
 export const InputGrafanaLokiAuthAuthenticationType1$outboundSchema: z.ZodType<
-  InputGrafanaLokiAuthAuthenticationType1,
+  string,
   z.ZodTypeDef,
   InputGrafanaLokiAuthAuthenticationType1
-> = z.union([
-  z.nativeEnum(InputGrafanaLokiAuthAuthenticationType1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputGrafanaLokiAuthAuthenticationType1);
 
 /** @internal */
 export const LokiAuthOauthParam1$inboundSchema: z.ZodType<

package/src/models/inputhttp.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 InputHttpType = {
-  Http: "http",
-} as const;
-export type InputHttpType = ClosedEnum<typeof InputHttpType>;
-
 export type InputHttpConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -184,7 +175,7 @@ export type InputHttp = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputHttpType;
+  type: "http";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -292,15 +283,6 @@ export type InputHttp = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputHttpType$inboundSchema: z.ZodNativeEnum<
-  typeof InputHttpType
-> = z.nativeEnum(InputHttpType);
-/** @internal */
-export const InputHttpType$outboundSchema: z.ZodNativeEnum<
-  typeof InputHttpType
-> = InputHttpType$inboundSchema;
-
 /** @internal */
 export const InputHttpConnection$inboundSchema: z.ZodType<
   InputHttpConnection,
@@ -348,40 +330,26 @@ export const InputHttpMode$inboundSchema: z.ZodType<
   InputHttpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpMode);
 /** @internal */
 export const InputHttpMode$outboundSchema: z.ZodType<
-  InputHttpMode,
+  string,
   z.ZodTypeDef,
   InputHttpMode
-> = z.union([
-  z.nativeEnum(InputHttpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpMode);
 
 /** @internal */
 export const InputHttpCompression$inboundSchema: z.ZodType<
   InputHttpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpCompression);
 /** @internal */
 export const InputHttpCompression$outboundSchema: z.ZodType<
-  InputHttpCompression,
+  string,
   z.ZodTypeDef,
   InputHttpCompression
-> = z.union([
-  z.nativeEnum(InputHttpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpCompression);
 
 /** @internal */
 export const InputHttpPqControls$inboundSchema: z.ZodType<
@@ -477,40 +445,26 @@ export const InputHttpMinimumTLSVersion$inboundSchema: z.ZodType<
   InputHttpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpMinimumTLSVersion);
 /** @internal */
 export const InputHttpMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputHttpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputHttpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputHttpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpMinimumTLSVersion);
 
 /** @internal */
 export const InputHttpMaximumTLSVersion$inboundSchema: z.ZodType<
   InputHttpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpMaximumTLSVersion);
 /** @internal */
 export const InputHttpMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputHttpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputHttpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputHttpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpMaximumTLSVersion);
 
 /** @internal */
 export const InputHttpTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -724,7 +678,7 @@ export const InputHttp$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputHttpType$inboundSchema,
+  type: z.literal("http"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -761,7 +715,7 @@ export const InputHttp$inboundSchema: z.ZodType<
 /** @internal */
 export type InputHttp$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "http";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -801,7 +755,7 @@ export const InputHttp$outboundSchema: z.ZodType<
   InputHttp
 > = z.object({
   id: z.string().optional(),
-  type: InputHttpType$outboundSchema,
+  type: z.literal("http"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputhttpraw.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 InputHttpRawType = {
-  HttpRaw: "http_raw",
-} as const;
-export type InputHttpRawType = ClosedEnum<typeof InputHttpRawType>;
-
 export type InputHttpRawConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -184,7 +175,7 @@ export type InputHttpRaw = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputHttpRawType;
+  type: "http_raw";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -295,15 +286,6 @@ export type InputHttpRaw = {
   description?: string | undefined;
 };
 
-/** @internal */
-export const InputHttpRawType$inboundSchema: z.ZodNativeEnum<
-  typeof InputHttpRawType
-> = z.nativeEnum(InputHttpRawType);
-/** @internal */
-export const InputHttpRawType$outboundSchema: z.ZodNativeEnum<
-  typeof InputHttpRawType
-> = InputHttpRawType$inboundSchema;
-
 /** @internal */
 export const InputHttpRawConnection$inboundSchema: z.ZodType<
   InputHttpRawConnection,
@@ -351,40 +333,26 @@ export const InputHttpRawMode$inboundSchema: z.ZodType<
   InputHttpRawMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpRawMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpRawMode);
 /** @internal */
 export const InputHttpRawMode$outboundSchema: z.ZodType<
-  InputHttpRawMode,
+  string,
   z.ZodTypeDef,
   InputHttpRawMode
-> = z.union([
-  z.nativeEnum(InputHttpRawMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpRawMode);
 
 /** @internal */
 export const InputHttpRawCompression$inboundSchema: z.ZodType<
   InputHttpRawCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpRawCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpRawCompression);
 /** @internal */
 export const InputHttpRawCompression$outboundSchema: z.ZodType<
-  InputHttpRawCompression,
+  string,
   z.ZodTypeDef,
   InputHttpRawCompression
-> = z.union([
-  z.nativeEnum(InputHttpRawCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpRawCompression);
 
 /** @internal */
 export const InputHttpRawPqControls$inboundSchema: z.ZodType<
@@ -480,40 +448,26 @@ export const InputHttpRawMinimumTLSVersion$inboundSchema: z.ZodType<
   InputHttpRawMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpRawMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpRawMinimumTLSVersion);
 /** @internal */
 export const InputHttpRawMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputHttpRawMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputHttpRawMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputHttpRawMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpRawMinimumTLSVersion);
 
 /** @internal */
 export const InputHttpRawMaximumTLSVersion$inboundSchema: z.ZodType<
   InputHttpRawMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputHttpRawMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputHttpRawMaximumTLSVersion);
 /** @internal */
 export const InputHttpRawMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputHttpRawMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputHttpRawMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputHttpRawMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputHttpRawMaximumTLSVersion);
 
 /** @internal */
 export const InputHttpRawTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -729,7 +683,7 @@ export const InputHttpRaw$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputHttpRawType$inboundSchema,
+  type: z.literal("http_raw"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -767,7 +721,7 @@ export const InputHttpRaw$inboundSchema: z.ZodType<
 /** @internal */
 export type InputHttpRaw$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "http_raw";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -807,7 +761,7 @@ export const InputHttpRaw$outboundSchema: z.ZodType<
   InputHttpRaw
 > = z.object({
   id: z.string().optional(),
-  type: InputHttpRawType$outboundSchema,
+  type: z.literal("http_raw"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),