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

package/src/models/inputsecuritylake.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";
 
@@ -390,40 +386,26 @@ export const InputSecurityLakeMode$inboundSchema: z.ZodType<
   InputSecurityLakeMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSecurityLakeMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSecurityLakeMode);
 /** @internal */
 export const InputSecurityLakeMode$outboundSchema: z.ZodType<
-  InputSecurityLakeMode,
+  string,
   z.ZodTypeDef,
   InputSecurityLakeMode
-> = z.union([
-  z.nativeEnum(InputSecurityLakeMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSecurityLakeMode);
 
 /** @internal */
 export const InputSecurityLakeCompression$inboundSchema: z.ZodType<
   InputSecurityLakeCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSecurityLakeCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSecurityLakeCompression);
 /** @internal */
 export const InputSecurityLakeCompression$outboundSchema: z.ZodType<
-  InputSecurityLakeCompression,
+  string,
   z.ZodTypeDef,
   InputSecurityLakeCompression
-> = z.union([
-  z.nativeEnum(InputSecurityLakeCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSecurityLakeCompression);
 
 /** @internal */
 export const InputSecurityLakePqControls$inboundSchema: z.ZodType<
@@ -527,40 +509,26 @@ export const InputSecurityLakeAuthenticationMethod$inboundSchema: z.ZodType<
   InputSecurityLakeAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSecurityLakeAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSecurityLakeAuthenticationMethod);
 /** @internal */
 export const InputSecurityLakeAuthenticationMethod$outboundSchema: z.ZodType<
-  InputSecurityLakeAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputSecurityLakeAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputSecurityLakeAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSecurityLakeAuthenticationMethod);
 
 /** @internal */
 export const InputSecurityLakeSignatureVersion$inboundSchema: z.ZodType<
   InputSecurityLakeSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSecurityLakeSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSecurityLakeSignatureVersion);
 /** @internal */
 export const InputSecurityLakeSignatureVersion$outboundSchema: z.ZodType<
-  InputSecurityLakeSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputSecurityLakeSignatureVersion
-> = z.union([
-  z.nativeEnum(InputSecurityLakeSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSecurityLakeSignatureVersion);
 
 /** @internal */
 export const InputSecurityLakePreprocess$inboundSchema: z.ZodType<
@@ -700,20 +668,13 @@ export const InputSecurityLakeTagAfterProcessing$inboundSchema: z.ZodType<
   InputSecurityLakeTagAfterProcessing,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSecurityLakeTagAfterProcessing),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSecurityLakeTagAfterProcessing);
 /** @internal */
 export const InputSecurityLakeTagAfterProcessing$outboundSchema: z.ZodType<
-  InputSecurityLakeTagAfterProcessing,
+  string,
   z.ZodTypeDef,
   InputSecurityLakeTagAfterProcessing
-> = z.union([
-  z.nativeEnum(InputSecurityLakeTagAfterProcessing),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSecurityLakeTagAfterProcessing);
 
 /** @internal */
 export const InputSecurityLake$inboundSchema: z.ZodType<

package/src/models/inputsnmp.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";
 
@@ -307,40 +303,26 @@ export const InputSnmpMode$inboundSchema: z.ZodType<
   InputSnmpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSnmpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSnmpMode);
 /** @internal */
 export const InputSnmpMode$outboundSchema: z.ZodType<
-  InputSnmpMode,
+  string,
   z.ZodTypeDef,
   InputSnmpMode
-> = z.union([
-  z.nativeEnum(InputSnmpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSnmpMode);
 
 /** @internal */
 export const InputSnmpCompression$inboundSchema: z.ZodType<
   InputSnmpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSnmpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSnmpCompression);
 /** @internal */
 export const InputSnmpCompression$outboundSchema: z.ZodType<
-  InputSnmpCompression,
+  string,
   z.ZodTypeDef,
   InputSnmpCompression
-> = z.union([
-  z.nativeEnum(InputSnmpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSnmpCompression);
 
 /** @internal */
 export const InputSnmpPqControls$inboundSchema: z.ZodType<
@@ -436,40 +418,26 @@ export const AuthenticationProtocol$inboundSchema: z.ZodType<
   AuthenticationProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(AuthenticationProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(AuthenticationProtocol);
 /** @internal */
 export const AuthenticationProtocol$outboundSchema: z.ZodType<
-  AuthenticationProtocol,
+  string,
   z.ZodTypeDef,
   AuthenticationProtocol
-> = z.union([
-  z.nativeEnum(AuthenticationProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(AuthenticationProtocol);
 
 /** @internal */
 export const PrivacyProtocol$inboundSchema: z.ZodType<
   PrivacyProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(PrivacyProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(PrivacyProtocol);
 /** @internal */
 export const PrivacyProtocol$outboundSchema: z.ZodType<
-  PrivacyProtocol,
+  string,
   z.ZodTypeDef,
   PrivacyProtocol
-> = z.union([
-  z.nativeEnum(PrivacyProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(PrivacyProtocol);
 
 /** @internal */
 export const V3User$inboundSchema: z.ZodType<V3User, z.ZodTypeDef, unknown> = z

package/src/models/inputsplunk.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";
 
@@ -371,40 +367,26 @@ export const InputSplunkMode$inboundSchema: z.ZodType<
   InputSplunkMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkMode);
 /** @internal */
 export const InputSplunkMode$outboundSchema: z.ZodType<
-  InputSplunkMode,
+  string,
   z.ZodTypeDef,
   InputSplunkMode
-> = z.union([
-  z.nativeEnum(InputSplunkMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkMode);
 
 /** @internal */
 export const InputSplunkPqCompression$inboundSchema: z.ZodType<
   InputSplunkPqCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkPqCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkPqCompression);
 /** @internal */
 export const InputSplunkPqCompression$outboundSchema: z.ZodType<
-  InputSplunkPqCompression,
+  string,
   z.ZodTypeDef,
   InputSplunkPqCompression
-> = z.union([
-  z.nativeEnum(InputSplunkPqCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkPqCompression);
 
 /** @internal */
 export const InputSplunkPqControls$inboundSchema: z.ZodType<
@@ -500,40 +482,26 @@ export const InputSplunkMinimumTLSVersion$inboundSchema: z.ZodType<
   InputSplunkMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkMinimumTLSVersion);
 /** @internal */
 export const InputSplunkMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputSplunkMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputSplunkMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputSplunkMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkMinimumTLSVersion);
 
 /** @internal */
 export const InputSplunkMaximumTLSVersion$inboundSchema: z.ZodType<
   InputSplunkMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkMaximumTLSVersion);
 /** @internal */
 export const InputSplunkMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputSplunkMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputSplunkMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputSplunkMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkMaximumTLSVersion);
 
 /** @internal */
 export const InputSplunkTLSSettingsServerSide$inboundSchema: z.ZodType<
@@ -695,40 +663,26 @@ export const InputSplunkMaxS2SVersion$inboundSchema: z.ZodType<
   InputSplunkMaxS2SVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkMaxS2SVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkMaxS2SVersion);
 /** @internal */
 export const InputSplunkMaxS2SVersion$outboundSchema: z.ZodType<
-  InputSplunkMaxS2SVersion,
+  string,
   z.ZodTypeDef,
   InputSplunkMaxS2SVersion
-> = z.union([
-  z.nativeEnum(InputSplunkMaxS2SVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkMaxS2SVersion);
 
 /** @internal */
 export const InputSplunkCompression$inboundSchema: z.ZodType<
   InputSplunkCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkCompression);
 /** @internal */
 export const InputSplunkCompression$outboundSchema: z.ZodType<
-  InputSplunkCompression,
+  string,
   z.ZodTypeDef,
   InputSplunkCompression
-> = z.union([
-  z.nativeEnum(InputSplunkCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkCompression);
 
 /** @internal */
 export const InputSplunk$inboundSchema: z.ZodType<

package/src/models/inputsplunkhec.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";
 
@@ -404,40 +400,26 @@ export const InputSplunkHecMode$inboundSchema: z.ZodType<
   InputSplunkHecMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkHecMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkHecMode);
 /** @internal */
 export const InputSplunkHecMode$outboundSchema: z.ZodType<
-  InputSplunkHecMode,
+  string,
   z.ZodTypeDef,
   InputSplunkHecMode
-> = z.union([
-  z.nativeEnum(InputSplunkHecMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkHecMode);
 
 /** @internal */
 export const InputSplunkHecCompression$inboundSchema: z.ZodType<
   InputSplunkHecCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkHecCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkHecCompression);
 /** @internal */
 export const InputSplunkHecCompression$outboundSchema: z.ZodType<
-  InputSplunkHecCompression,
+  string,
   z.ZodTypeDef,
   InputSplunkHecCompression
-> = z.union([
-  z.nativeEnum(InputSplunkHecCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkHecCompression);
 
 /** @internal */
 export const InputSplunkHecPqControls$inboundSchema: z.ZodType<
@@ -537,20 +519,13 @@ export const InputSplunkHecAuthenticationMethod$inboundSchema: z.ZodType<
   InputSplunkHecAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkHecAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkHecAuthenticationMethod);
 /** @internal */
 export const InputSplunkHecAuthenticationMethod$outboundSchema: z.ZodType<
-  InputSplunkHecAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputSplunkHecAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputSplunkHecAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkHecAuthenticationMethod);
 
 /** @internal */
 export const InputSplunkHecAuthTokenMetadatum$inboundSchema: z.ZodType<
@@ -662,40 +637,26 @@ export const InputSplunkHecMinimumTLSVersion$inboundSchema: z.ZodType<
   InputSplunkHecMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkHecMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkHecMinimumTLSVersion);
 /** @internal */
 export const InputSplunkHecMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputSplunkHecMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputSplunkHecMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputSplunkHecMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkHecMinimumTLSVersion);
 
 /** @internal */
 export const InputSplunkHecMaximumTLSVersion$inboundSchema: z.ZodType<
   InputSplunkHecMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputSplunkHecMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputSplunkHecMaximumTLSVersion);
 /** @internal */
 export const InputSplunkHecMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputSplunkHecMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputSplunkHecMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputSplunkHecMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputSplunkHecMaximumTLSVersion);
 
 /** @internal */
 export const InputSplunkHecTLSSettingsServerSide$inboundSchema: z.ZodType<

package/src/models/inputsplunksearch.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";
 
@@ -478,40 +474,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<
@@ -615,20 +597,13 @@ export const OutputMode$inboundSchema: z.ZodType<
   OutputMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputMode);
 /** @internal */
 export const OutputMode$outboundSchema: z.ZodType<
-  OutputMode,
+  string,
   z.ZodTypeDef,
   OutputMode
-> = z.union([
-  z.nativeEnum(OutputMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputMode);
 
 /** @internal */
 export const EndpointParam$inboundSchema: z.ZodType<
@@ -711,20 +686,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 +741,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 +816,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<