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

package/src/models/inputcribl.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";
 
@@ -197,40 +193,26 @@ export const InputCriblMode$inboundSchema: z.ZodType<
   InputCriblMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblMode);
 /** @internal */
 export const InputCriblMode$outboundSchema: z.ZodType<
-  InputCriblMode,
+  string,
   z.ZodTypeDef,
   InputCriblMode
-> = z.union([
-  z.nativeEnum(InputCriblMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblMode);
 
 /** @internal */
 export const InputCriblCompression$inboundSchema: z.ZodType<
   InputCriblCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblCompression);
 /** @internal */
 export const InputCriblCompression$outboundSchema: z.ZodType<
-  InputCriblCompression,
+  string,
   z.ZodTypeDef,
   InputCriblCompression
-> = z.union([
-  z.nativeEnum(InputCriblCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblCompression);
 
 /** @internal */
 export const InputCriblPqControls$inboundSchema: z.ZodType<

package/src/models/inputcriblhttp.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";
 
@@ -325,40 +321,26 @@ export const InputCriblHttpMode$inboundSchema: z.ZodType<
   InputCriblHttpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblHttpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblHttpMode);
 /** @internal */
 export const InputCriblHttpMode$outboundSchema: z.ZodType<
-  InputCriblHttpMode,
+  string,
   z.ZodTypeDef,
   InputCriblHttpMode
-> = z.union([
-  z.nativeEnum(InputCriblHttpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblHttpMode);
 
 /** @internal */
 export const InputCriblHttpCompression$inboundSchema: z.ZodType<
   InputCriblHttpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblHttpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblHttpCompression);
 /** @internal */
 export const InputCriblHttpCompression$outboundSchema: z.ZodType<
-  InputCriblHttpCompression,
+  string,
   z.ZodTypeDef,
   InputCriblHttpCompression
-> = z.union([
-  z.nativeEnum(InputCriblHttpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblHttpCompression);
 
 /** @internal */
 export const InputCriblHttpPqControls$inboundSchema: z.ZodType<
@@ -503,40 +485,26 @@ export const InputCriblHttpMinimumTLSVersion$inboundSchema: z.ZodType<
   InputCriblHttpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblHttpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblHttpMinimumTLSVersion);
 /** @internal */
 export const InputCriblHttpMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputCriblHttpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputCriblHttpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputCriblHttpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblHttpMinimumTLSVersion);
 
 /** @internal */
 export const InputCriblHttpMaximumTLSVersion$inboundSchema: z.ZodType<
   InputCriblHttpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblHttpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblHttpMaximumTLSVersion);
 /** @internal */
 export const InputCriblHttpMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputCriblHttpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputCriblHttpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputCriblHttpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblHttpMaximumTLSVersion);
 
 /** @internal */
 export const InputCriblHttpTLSSettingsServerSide$inboundSchema: z.ZodType<

package/src/models/inputcribllakehttp.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";
 
@@ -359,40 +355,26 @@ export const InputCriblLakeHttpMode$inboundSchema: z.ZodType<
   InputCriblLakeHttpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblLakeHttpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblLakeHttpMode);
 /** @internal */
 export const InputCriblLakeHttpMode$outboundSchema: z.ZodType<
-  InputCriblLakeHttpMode,
+  string,
   z.ZodTypeDef,
   InputCriblLakeHttpMode
-> = z.union([
-  z.nativeEnum(InputCriblLakeHttpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblLakeHttpMode);
 
 /** @internal */
 export const InputCriblLakeHttpCompression$inboundSchema: z.ZodType<
   InputCriblLakeHttpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblLakeHttpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblLakeHttpCompression);
 /** @internal */
 export const InputCriblLakeHttpCompression$outboundSchema: z.ZodType<
-  InputCriblLakeHttpCompression,
+  string,
   z.ZodTypeDef,
   InputCriblLakeHttpCompression
-> = z.union([
-  z.nativeEnum(InputCriblLakeHttpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblLakeHttpCompression);
 
 /** @internal */
 export const InputCriblLakeHttpPqControls$inboundSchema: z.ZodType<
@@ -496,40 +478,26 @@ export const InputCriblLakeHttpMinimumTLSVersion$inboundSchema: z.ZodType<
   InputCriblLakeHttpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblLakeHttpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblLakeHttpMinimumTLSVersion);
 /** @internal */
 export const InputCriblLakeHttpMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputCriblLakeHttpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputCriblLakeHttpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputCriblLakeHttpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblLakeHttpMinimumTLSVersion);
 
 /** @internal */
 export const InputCriblLakeHttpMaximumTLSVersion$inboundSchema: z.ZodType<
   InputCriblLakeHttpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblLakeHttpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblLakeHttpMaximumTLSVersion);
 /** @internal */
 export const InputCriblLakeHttpMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputCriblLakeHttpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputCriblLakeHttpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputCriblLakeHttpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblLakeHttpMaximumTLSVersion);
 
 /** @internal */
 export const InputCriblLakeHttpTLSSettingsServerSide$inboundSchema: z.ZodType<

package/src/models/inputcriblmetrics.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";
 
@@ -208,40 +204,26 @@ export const InputCriblmetricsMode$inboundSchema: z.ZodType<
   InputCriblmetricsMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblmetricsMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblmetricsMode);
 /** @internal */
 export const InputCriblmetricsMode$outboundSchema: z.ZodType<
-  InputCriblmetricsMode,
+  string,
   z.ZodTypeDef,
   InputCriblmetricsMode
-> = z.union([
-  z.nativeEnum(InputCriblmetricsMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblmetricsMode);
 
 /** @internal */
 export const InputCriblmetricsCompression$inboundSchema: z.ZodType<
   InputCriblmetricsCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblmetricsCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblmetricsCompression);
 /** @internal */
 export const InputCriblmetricsCompression$outboundSchema: z.ZodType<
-  InputCriblmetricsCompression,
+  string,
   z.ZodTypeDef,
   InputCriblmetricsCompression
-> = z.union([
-  z.nativeEnum(InputCriblmetricsCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblmetricsCompression);
 
 /** @internal */
 export const InputCriblmetricsPqControls$inboundSchema: z.ZodType<

package/src/models/inputcribltcp.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";
 
@@ -305,40 +301,26 @@ export const InputCriblTcpMode$inboundSchema: z.ZodType<
   InputCriblTcpMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblTcpMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblTcpMode);
 /** @internal */
 export const InputCriblTcpMode$outboundSchema: z.ZodType<
-  InputCriblTcpMode,
+  string,
   z.ZodTypeDef,
   InputCriblTcpMode
-> = z.union([
-  z.nativeEnum(InputCriblTcpMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblTcpMode);
 
 /** @internal */
 export const InputCriblTcpCompression$inboundSchema: z.ZodType<
   InputCriblTcpCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblTcpCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblTcpCompression);
 /** @internal */
 export const InputCriblTcpCompression$outboundSchema: z.ZodType<
-  InputCriblTcpCompression,
+  string,
   z.ZodTypeDef,
   InputCriblTcpCompression
-> = z.union([
-  z.nativeEnum(InputCriblTcpCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblTcpCompression);
 
 /** @internal */
 export const InputCriblTcpPqControls$inboundSchema: z.ZodType<
@@ -436,40 +418,26 @@ export const InputCriblTcpMinimumTLSVersion$inboundSchema: z.ZodType<
   InputCriblTcpMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblTcpMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblTcpMinimumTLSVersion);
 /** @internal */
 export const InputCriblTcpMinimumTLSVersion$outboundSchema: z.ZodType<
-  InputCriblTcpMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputCriblTcpMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(InputCriblTcpMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblTcpMinimumTLSVersion);
 
 /** @internal */
 export const InputCriblTcpMaximumTLSVersion$inboundSchema: z.ZodType<
   InputCriblTcpMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCriblTcpMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCriblTcpMaximumTLSVersion);
 /** @internal */
 export const InputCriblTcpMaximumTLSVersion$outboundSchema: z.ZodType<
-  InputCriblTcpMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   InputCriblTcpMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(InputCriblTcpMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCriblTcpMaximumTLSVersion);
 
 /** @internal */
 export const InputCriblTcpTLSSettingsServerSide$inboundSchema: z.ZodType<

package/src/models/inputcrowdstrike.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";
 
@@ -380,40 +376,26 @@ export const InputCrowdstrikeMode$inboundSchema: z.ZodType<
   InputCrowdstrikeMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCrowdstrikeMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCrowdstrikeMode);
 /** @internal */
 export const InputCrowdstrikeMode$outboundSchema: z.ZodType<
-  InputCrowdstrikeMode,
+  string,
   z.ZodTypeDef,
   InputCrowdstrikeMode
-> = z.union([
-  z.nativeEnum(InputCrowdstrikeMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCrowdstrikeMode);
 
 /** @internal */
 export const InputCrowdstrikeCompression$inboundSchema: z.ZodType<
   InputCrowdstrikeCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCrowdstrikeCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCrowdstrikeCompression);
 /** @internal */
 export const InputCrowdstrikeCompression$outboundSchema: z.ZodType<
-  InputCrowdstrikeCompression,
+  string,
   z.ZodTypeDef,
   InputCrowdstrikeCompression
-> = z.union([
-  z.nativeEnum(InputCrowdstrikeCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCrowdstrikeCompression);
 
 /** @internal */
 export const InputCrowdstrikePqControls$inboundSchema: z.ZodType<
@@ -514,40 +496,26 @@ export const InputCrowdstrikeAuthenticationMethod$inboundSchema: z.ZodType<
   InputCrowdstrikeAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCrowdstrikeAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCrowdstrikeAuthenticationMethod);
 /** @internal */
 export const InputCrowdstrikeAuthenticationMethod$outboundSchema: z.ZodType<
-  InputCrowdstrikeAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   InputCrowdstrikeAuthenticationMethod
-> = z.union([
-  z.nativeEnum(InputCrowdstrikeAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCrowdstrikeAuthenticationMethod);
 
 /** @internal */
 export const InputCrowdstrikeSignatureVersion$inboundSchema: z.ZodType<
   InputCrowdstrikeSignatureVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCrowdstrikeSignatureVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCrowdstrikeSignatureVersion);
 /** @internal */
 export const InputCrowdstrikeSignatureVersion$outboundSchema: z.ZodType<
-  InputCrowdstrikeSignatureVersion,
+  string,
   z.ZodTypeDef,
   InputCrowdstrikeSignatureVersion
-> = z.union([
-  z.nativeEnum(InputCrowdstrikeSignatureVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCrowdstrikeSignatureVersion);
 
 /** @internal */
 export const InputCrowdstrikePreprocess$inboundSchema: z.ZodType<
@@ -685,20 +653,13 @@ export const InputCrowdstrikeTagAfterProcessing$inboundSchema: z.ZodType<
   InputCrowdstrikeTagAfterProcessing,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputCrowdstrikeTagAfterProcessing),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputCrowdstrikeTagAfterProcessing);
 /** @internal */
 export const InputCrowdstrikeTagAfterProcessing$outboundSchema: z.ZodType<
-  InputCrowdstrikeTagAfterProcessing,
+  string,
   z.ZodTypeDef,
   InputCrowdstrikeTagAfterProcessing
-> = z.union([
-  z.nativeEnum(InputCrowdstrikeTagAfterProcessing),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(InputCrowdstrikeTagAfterProcessing);
 
 /** @internal */
 export const InputCrowdstrike$inboundSchema: z.ZodType<