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

package/src/models/inputsplunksearch.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 InputSplunkSearchType = {
-  SplunkSearch: "splunk_search",
-} as const;
-export type InputSplunkSearchType = ClosedEnum<typeof InputSplunkSearchType>;
-
 export type InputSplunkSearchConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -98,14 +89,16 @@ export type InputSplunkSearchPq = {
 /**
  * Format of the returned output
  */
-export const OutputMode = {
+export const InputSplunkSearchOutputMode = {
   Csv: "csv",
   Json: "json",
 } as const;
 /**
  * Format of the returned output
  */
-export type OutputMode = OpenEnum<typeof OutputMode>;
+export type InputSplunkSearchOutputMode = OpenEnum<
+  typeof InputSplunkSearchOutputMode
+>;
 
 export type EndpointParam = {
   name: string;
@@ -251,7 +244,7 @@ export type InputSplunkSearch = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputSplunkSearchType;
+  type: "splunk_search";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -305,7 +298,7 @@ export type InputSplunkSearch = {
   /**
    * Format of the returned output
    */
-  outputMode?: OutputMode | undefined;
+  outputMode?: InputSplunkSearchOutputMode | undefined;
   /**
    * Optional request parameters to send to the endpoint
    */
@@ -420,15 +413,6 @@ export type InputSplunkSearch = {
   oauthHeaders?: Array<InputSplunkSearchOauthHeader> | undefined;
 };
 
-/** @internal */
-export const InputSplunkSearchType$inboundSchema: z.ZodNativeEnum<
-  typeof InputSplunkSearchType
-> = z.nativeEnum(InputSplunkSearchType);
-/** @internal */
-export const InputSplunkSearchType$outboundSchema: z.ZodNativeEnum<
-  typeof InputSplunkSearchType
-> = InputSplunkSearchType$inboundSchema;
-
 /** @internal */
 export const InputSplunkSearchConnection$inboundSchema: z.ZodType<
   InputSplunkSearchConnection,
@@ -478,40 +462,26 @@ export const InputSplunkSearchMode$inboundSchema: z.ZodType<
   InputSplunkSearchMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkSearchMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkSearchMode);
 /** @internal */
 export const InputSplunkSearchMode$outboundSchema: z.ZodType<
-  InputSplunkSearchMode,
+  string,
   z.ZodTypeDef,
   InputSplunkSearchMode
-> = z.union([
-  z.nativeEnum(InputSplunkSearchMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkSearchMode);
 
 /** @internal */
 export const InputSplunkSearchCompression$inboundSchema: z.ZodType<
   InputSplunkSearchCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkSearchCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkSearchCompression);
 /** @internal */
 export const InputSplunkSearchCompression$outboundSchema: z.ZodType<
-  InputSplunkSearchCompression,
+  string,
   z.ZodTypeDef,
   InputSplunkSearchCompression
-> = z.union([
-  z.nativeEnum(InputSplunkSearchCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkSearchCompression);
 
 /** @internal */
 export const InputSplunkSearchPqControls$inboundSchema: z.ZodType<
@@ -611,24 +581,17 @@ export function inputSplunkSearchPqFromJSON(
 }
 
 /** @internal */
-export const OutputMode$inboundSchema: z.ZodType<
-  OutputMode,
+export const InputSplunkSearchOutputMode$inboundSchema: z.ZodType<
+  InputSplunkSearchOutputMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkSearchOutputMode);
 /** @internal */
-export const OutputMode$outboundSchema: z.ZodType<
-  OutputMode,
+export const InputSplunkSearchOutputMode$outboundSchema: z.ZodType<
+  string,
   z.ZodTypeDef,
-  OutputMode
-> = z.union([
-  z.nativeEnum(OutputMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+  InputSplunkSearchOutputMode
+> = openEnums.outboundSchema(InputSplunkSearchOutputMode);
 
 /** @internal */
 export const EndpointParam$inboundSchema: z.ZodType<
@@ -711,20 +674,13 @@ export const InputSplunkSearchLogLevel$inboundSchema: z.ZodType<
   InputSplunkSearchLogLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkSearchLogLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkSearchLogLevel);
 /** @internal */
 export const InputSplunkSearchLogLevel$outboundSchema: z.ZodType<
-  InputSplunkSearchLogLevel,
+  string,
   z.ZodTypeDef,
   InputSplunkSearchLogLevel
-> = z.union([
-  z.nativeEnum(InputSplunkSearchLogLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkSearchLogLevel);
 
 /** @internal */
 export const InputSplunkSearchMetadatum$inboundSchema: z.ZodType<
@@ -773,20 +729,13 @@ export const InputSplunkSearchRetryType$inboundSchema: z.ZodType<
   InputSplunkSearchRetryType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkSearchRetryType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkSearchRetryType);
 /** @internal */
 export const InputSplunkSearchRetryType$outboundSchema: z.ZodType<
-  InputSplunkSearchRetryType,
+  string,
   z.ZodTypeDef,
   InputSplunkSearchRetryType
-> = z.union([
-  z.nativeEnum(InputSplunkSearchRetryType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkSearchRetryType);
 
 /** @internal */
 export const InputSplunkSearchRetryRules$inboundSchema: z.ZodType<
@@ -855,20 +804,13 @@ export const InputSplunkSearchAuthenticationType$inboundSchema: z.ZodType<
   InputSplunkSearchAuthenticationType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkSearchAuthenticationType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkSearchAuthenticationType);
 /** @internal */
 export const InputSplunkSearchAuthenticationType$outboundSchema: z.ZodType<
-  InputSplunkSearchAuthenticationType,
+  string,
   z.ZodTypeDef,
   InputSplunkSearchAuthenticationType
-> = z.union([
-  z.nativeEnum(InputSplunkSearchAuthenticationType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkSearchAuthenticationType);
 
 /** @internal */
 export const InputSplunkSearchOauthParam$inboundSchema: z.ZodType<
@@ -965,7 +907,7 @@ export const InputSplunkSearch$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputSplunkSearchType$inboundSchema,
+  type: z.literal("splunk_search"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -981,7 +923,7 @@ export const InputSplunkSearch$inboundSchema: z.ZodType<
   latest: z.string().default("-1m@m"),
   cronSchedule: z.string().default("*/15 * * * *"),
   endpoint: z.string().default("/services/search/v2/jobs/export"),
-  outputMode: OutputMode$inboundSchema.default("json"),
+  outputMode: InputSplunkSearchOutputMode$inboundSchema.default("json"),
   endpointParams: z.array(z.lazy(() => EndpointParam$inboundSchema)).optional(),
   endpointHeaders: z.array(z.lazy(() => EndpointHeader$inboundSchema))
     .optional(),
@@ -1023,7 +965,7 @@ export const InputSplunkSearch$inboundSchema: z.ZodType<
 /** @internal */
 export type InputSplunkSearch$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "splunk_search";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -1079,7 +1021,7 @@ export const InputSplunkSearch$outboundSchema: z.ZodType<
   InputSplunkSearch
 > = z.object({
   id: z.string().optional(),
-  type: InputSplunkSearchType$outboundSchema,
+  type: z.literal("splunk_search"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -1095,7 +1037,7 @@ export const InputSplunkSearch$outboundSchema: z.ZodType<
   latest: z.string().default("-1m@m"),
   cronSchedule: z.string().default("*/15 * * * *"),
   endpoint: z.string().default("/services/search/v2/jobs/export"),
-  outputMode: OutputMode$outboundSchema.default("json"),
+  outputMode: InputSplunkSearchOutputMode$outboundSchema.default("json"),
   endpointParams: z.array(z.lazy(() => EndpointParam$outboundSchema))
     .optional(),
   endpointHeaders: z.array(z.lazy(() => EndpointHeader$outboundSchema))

package/src/models/inputsqs.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 InputSqsType = {
-  Sqs: "sqs",
-} as const;
-export type InputSqsType = ClosedEnum<typeof InputSqsType>;
-
 export type InputSqsConnection = {
   pipeline?: string | undefined;
   output: string;
@@ -162,7 +153,7 @@ export type InputSqs = {
    * Unique ID for this input
    */
   id?: string | undefined;
-  type: InputSqsType;
+  type: "sqs";
   disabled?: boolean | undefined;
   /**
    * Pipeline to process data from this Source before sending it through the Routes
@@ -274,13 +265,6 @@ export type InputSqs = {
   numReceivers?: number | undefined;
 };
 
-/** @internal */
-export const InputSqsType$inboundSchema: z.ZodNativeEnum<typeof InputSqsType> =
-  z.nativeEnum(InputSqsType);
-/** @internal */
-export const InputSqsType$outboundSchema: z.ZodNativeEnum<typeof InputSqsType> =
-  InputSqsType$inboundSchema;
-
 /** @internal */
 export const InputSqsConnection$inboundSchema: z.ZodType<
   InputSqsConnection,
@@ -328,40 +312,26 @@ export const InputSqsMode$inboundSchema: z.ZodType<
   InputSqsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsMode);
 /** @internal */
 export const InputSqsMode$outboundSchema: z.ZodType<
-  InputSqsMode,
+  string,
   z.ZodTypeDef,
   InputSqsMode
-> = z.union([
-  z.nativeEnum(InputSqsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsMode);
 
 /** @internal */
 export const InputSqsCompression$inboundSchema: z.ZodType<
   InputSqsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsCompression);
 /** @internal */
 export const InputSqsCompression$outboundSchema: z.ZodType<
-  InputSqsCompression,
+  string,
   z.ZodTypeDef,
   InputSqsCompression
-> = z.union([
-  z.nativeEnum(InputSqsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsCompression);
 
 /** @internal */
 export const InputSqsPqControls$inboundSchema: z.ZodType<
@@ -457,60 +427,39 @@ export const InputSqsQueueType$inboundSchema: z.ZodType<
   InputSqsQueueType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsQueueType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsQueueType);
 /** @internal */
 export const InputSqsQueueType$outboundSchema: z.ZodType<
-  InputSqsQueueType,
+  string,
   z.ZodTypeDef,
   InputSqsQueueType
-> = z.union([
-  z.nativeEnum(InputSqsQueueType),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsQueueType);
 
 /** @internal */
 export const InputSqsAuthenticationMethod$inboundSchema: z.ZodType<
   InputSqsAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsAuthenticationMethod);
 /** @internal */
 export const InputSqsAuthenticationMethod$outboundSchema: z.ZodType<
-  InputSqsAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputSqsAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputSqsAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsAuthenticationMethod);
 
 /** @internal */
 export const InputSqsSignatureVersion$inboundSchema: z.ZodType<
   InputSqsSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSqsSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSqsSignatureVersion);
 /** @internal */
 export const InputSqsSignatureVersion$outboundSchema: z.ZodType<
-  InputSqsSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputSqsSignatureVersion
-> = z.union([
-  z.nativeEnum(InputSqsSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSqsSignatureVersion);
 
 /** @internal */
 export const InputSqsMetadatum$inboundSchema: z.ZodType<
@@ -561,7 +510,7 @@ export const InputSqs$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
-  type: InputSqsType$inboundSchema,
+  type: z.literal("sqs"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),
@@ -600,7 +549,7 @@ export const InputSqs$inboundSchema: z.ZodType<
 /** @internal */
 export type InputSqs$Outbound = {
   id?: string | undefined;
-  type: string;
+  type: "sqs";
   disabled: boolean;
   pipeline?: string | undefined;
   sendToRoutes: boolean;
@@ -641,7 +590,7 @@ export const InputSqs$outboundSchema: z.ZodType<
   InputSqs
 > = z.object({
   id: z.string().optional(),
-  type: InputSqsType$outboundSchema,
+  type: z.literal("sqs"),
   disabled: z.boolean().default(false),
   pipeline: z.string().optional(),
   sendToRoutes: z.boolean().default(true),

package/src/models/inputsyslog.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";
 
@@ -603,40 +599,26 @@ export const InputSyslogMode2$inboundSchema: z.ZodType<
   InputSyslogMode2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMode2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMode2);
 /** @internal */
 export const InputSyslogMode2$outboundSchema: z.ZodType<
-  InputSyslogMode2,
+  string,
   z.ZodTypeDef,
   InputSyslogMode2
-> = z.union([
-  z.nativeEnum(InputSyslogMode2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMode2);
 
 /** @internal */
 export const InputSyslogCompression2$inboundSchema: z.ZodType<
   InputSyslogCompression2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogCompression2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogCompression2);
 /** @internal */
 export const InputSyslogCompression2$outboundSchema: z.ZodType<
-  InputSyslogCompression2,
+  string,
   z.ZodTypeDef,
   InputSyslogCompression2
-> = z.union([
-  z.nativeEnum(InputSyslogCompression2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogCompression2);
 
 /** @internal */
 export const InputSyslogPqControls2$inboundSchema: z.ZodType<
@@ -732,40 +714,26 @@ export const InputSyslogMinimumTLSVersion2$inboundSchema: z.ZodType<
   InputSyslogMinimumTLSVersion2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMinimumTLSVersion2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMinimumTLSVersion2);
 /** @internal */
 export const InputSyslogMinimumTLSVersion2$outboundSchema: z.ZodType<
-  InputSyslogMinimumTLSVersion2,
+  string,
   z.ZodTypeDef,
   InputSyslogMinimumTLSVersion2
-> = z.union([
-  z.nativeEnum(InputSyslogMinimumTLSVersion2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMinimumTLSVersion2);
 
 /** @internal */
 export const InputSyslogMaximumTLSVersion2$inboundSchema: z.ZodType<
   InputSyslogMaximumTLSVersion2,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMaximumTLSVersion2),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMaximumTLSVersion2);
 /** @internal */
 export const InputSyslogMaximumTLSVersion2$outboundSchema: z.ZodType<
-  InputSyslogMaximumTLSVersion2,
+  string,
   z.ZodTypeDef,
   InputSyslogMaximumTLSVersion2
-> = z.union([
-  z.nativeEnum(InputSyslogMaximumTLSVersion2),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMaximumTLSVersion2);
 
 /** @internal */
 export const InputSyslogTLSSettingsServerSide2$inboundSchema: z.ZodType<
@@ -1076,40 +1044,26 @@ export const InputSyslogMode1$inboundSchema: z.ZodType<
   InputSyslogMode1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMode1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMode1);
 /** @internal */
 export const InputSyslogMode1$outboundSchema: z.ZodType<
-  InputSyslogMode1,
+  string,
   z.ZodTypeDef,
   InputSyslogMode1
-> = z.union([
-  z.nativeEnum(InputSyslogMode1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMode1);
 
 /** @internal */
 export const InputSyslogCompression1$inboundSchema: z.ZodType<
   InputSyslogCompression1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogCompression1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogCompression1);
 /** @internal */
 export const InputSyslogCompression1$outboundSchema: z.ZodType<
-  InputSyslogCompression1,
+  string,
   z.ZodTypeDef,
   InputSyslogCompression1
-> = z.union([
-  z.nativeEnum(InputSyslogCompression1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogCompression1);
 
 /** @internal */
 export const InputSyslogPqControls1$inboundSchema: z.ZodType<
@@ -1205,40 +1159,26 @@ export const InputSyslogMinimumTLSVersion1$inboundSchema: z.ZodType<
   InputSyslogMinimumTLSVersion1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMinimumTLSVersion1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMinimumTLSVersion1);
 /** @internal */
 export const InputSyslogMinimumTLSVersion1$outboundSchema: z.ZodType<
-  InputSyslogMinimumTLSVersion1,
+  string,
   z.ZodTypeDef,
   InputSyslogMinimumTLSVersion1
-> = z.union([
-  z.nativeEnum(InputSyslogMinimumTLSVersion1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMinimumTLSVersion1);
 
 /** @internal */
 export const InputSyslogMaximumTLSVersion1$inboundSchema: z.ZodType<
   InputSyslogMaximumTLSVersion1,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSyslogMaximumTLSVersion1),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSyslogMaximumTLSVersion1);
 /** @internal */
 export const InputSyslogMaximumTLSVersion1$outboundSchema: z.ZodType<
-  InputSyslogMaximumTLSVersion1,
+  string,
   z.ZodTypeDef,
   InputSyslogMaximumTLSVersion1
-> = z.union([
-  z.nativeEnum(InputSyslogMaximumTLSVersion1),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSyslogMaximumTLSVersion1);
 
 /** @internal */
 export const InputSyslogTLSSettingsServerSide1$inboundSchema: z.ZodType<