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

package/src/models/outputdatabricks.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,140 +376,91 @@ export const OutputDatabricksDataFormat$inboundSchema: z.ZodType<
   OutputDatabricksDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksDataFormat);
 /** @internal */
 export const OutputDatabricksDataFormat$outboundSchema: z.ZodType<
-  OutputDatabricksDataFormat,
+  string,
   z.ZodTypeDef,
   OutputDatabricksDataFormat
-> = z.union([
-  z.nativeEnum(OutputDatabricksDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksDataFormat);
 
 /** @internal */
 export const OutputDatabricksBackpressureBehavior$inboundSchema: z.ZodType<
   OutputDatabricksBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksBackpressureBehavior);
 /** @internal */
 export const OutputDatabricksBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputDatabricksBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputDatabricksBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputDatabricksBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksBackpressureBehavior);
 
 /** @internal */
 export const OutputDatabricksDiskSpaceProtection$inboundSchema: z.ZodType<
   OutputDatabricksDiskSpaceProtection,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksDiskSpaceProtection),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksDiskSpaceProtection);
 /** @internal */
 export const OutputDatabricksDiskSpaceProtection$outboundSchema: z.ZodType<
-  OutputDatabricksDiskSpaceProtection,
+  string,
   z.ZodTypeDef,
   OutputDatabricksDiskSpaceProtection
-> = z.union([
-  z.nativeEnum(OutputDatabricksDiskSpaceProtection),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksDiskSpaceProtection);
 
 /** @internal */
 export const OutputDatabricksCompression$inboundSchema: z.ZodType<
   OutputDatabricksCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksCompression);
 /** @internal */
 export const OutputDatabricksCompression$outboundSchema: z.ZodType<
-  OutputDatabricksCompression,
+  string,
   z.ZodTypeDef,
   OutputDatabricksCompression
-> = z.union([
-  z.nativeEnum(OutputDatabricksCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksCompression);
 
 /** @internal */
 export const OutputDatabricksCompressionLevel$inboundSchema: z.ZodType<
   OutputDatabricksCompressionLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksCompressionLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksCompressionLevel);
 /** @internal */
 export const OutputDatabricksCompressionLevel$outboundSchema: z.ZodType<
-  OutputDatabricksCompressionLevel,
+  string,
   z.ZodTypeDef,
   OutputDatabricksCompressionLevel
-> = z.union([
-  z.nativeEnum(OutputDatabricksCompressionLevel),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksCompressionLevel);
 
 /** @internal */
 export const OutputDatabricksParquetVersion$inboundSchema: z.ZodType<
   OutputDatabricksParquetVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksParquetVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksParquetVersion);
 /** @internal */
 export const OutputDatabricksParquetVersion$outboundSchema: z.ZodType<
-  OutputDatabricksParquetVersion,
+  string,
   z.ZodTypeDef,
   OutputDatabricksParquetVersion
-> = z.union([
-  z.nativeEnum(OutputDatabricksParquetVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksParquetVersion);
 
 /** @internal */
 export const OutputDatabricksDataPageVersion$inboundSchema: z.ZodType<
   OutputDatabricksDataPageVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatabricksDataPageVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatabricksDataPageVersion);
 /** @internal */
 export const OutputDatabricksDataPageVersion$outboundSchema: z.ZodType<
-  OutputDatabricksDataPageVersion,
+  string,
   z.ZodTypeDef,
   OutputDatabricksDataPageVersion
-> = z.union([
-  z.nativeEnum(OutputDatabricksDataPageVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatabricksDataPageVersion);
 
 /** @internal */
 export const OutputDatabricksKeyValueMetadatum$inboundSchema: z.ZodType<

package/src/models/outputdatadog.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";
 
@@ -484,60 +480,39 @@ export const SendLogsAs$inboundSchema: z.ZodType<
   SendLogsAs,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(SendLogsAs),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(SendLogsAs);
 /** @internal */
 export const SendLogsAs$outboundSchema: z.ZodType<
-  SendLogsAs,
+  string,
   z.ZodTypeDef,
   SendLogsAs
-> = z.union([
-  z.nativeEnum(SendLogsAs),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(SendLogsAs);
 
 /** @internal */
 export const OutputDatadogSeverity$inboundSchema: z.ZodType<
   OutputDatadogSeverity,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogSeverity),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogSeverity);
 /** @internal */
 export const OutputDatadogSeverity$outboundSchema: z.ZodType<
-  OutputDatadogSeverity,
+  string,
   z.ZodTypeDef,
   OutputDatadogSeverity
-> = z.union([
-  z.nativeEnum(OutputDatadogSeverity),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogSeverity);
 
 /** @internal */
 export const DatadogSite$inboundSchema: z.ZodType<
   DatadogSite,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(DatadogSite),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(DatadogSite);
 /** @internal */
 export const DatadogSite$outboundSchema: z.ZodType<
-  DatadogSite,
+  string,
   z.ZodTypeDef,
   DatadogSite
-> = z.union([
-  z.nativeEnum(DatadogSite),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(DatadogSite);
 
 /** @internal */
 export const OutputDatadogExtraHttpHeader$inboundSchema: z.ZodType<
@@ -588,20 +563,13 @@ export const OutputDatadogFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputDatadogFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogFailedRequestLoggingMode);
 /** @internal */
 export const OutputDatadogFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputDatadogFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputDatadogFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputDatadogFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputDatadogResponseRetrySetting$inboundSchema: z.ZodType<
@@ -708,100 +676,65 @@ export const OutputDatadogBackpressureBehavior$inboundSchema: z.ZodType<
   OutputDatadogBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogBackpressureBehavior);
 /** @internal */
 export const OutputDatadogBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputDatadogBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputDatadogBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputDatadogBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogBackpressureBehavior);
 
 /** @internal */
 export const OutputDatadogAuthenticationMethod$inboundSchema: z.ZodType<
   OutputDatadogAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogAuthenticationMethod);
 /** @internal */
 export const OutputDatadogAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputDatadogAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputDatadogAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputDatadogAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogAuthenticationMethod);
 
 /** @internal */
 export const OutputDatadogMode$inboundSchema: z.ZodType<
   OutputDatadogMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogMode);
 /** @internal */
 export const OutputDatadogMode$outboundSchema: z.ZodType<
-  OutputDatadogMode,
+  string,
   z.ZodTypeDef,
   OutputDatadogMode
-> = z.union([
-  z.nativeEnum(OutputDatadogMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogMode);
 
 /** @internal */
 export const OutputDatadogCompression$inboundSchema: z.ZodType<
   OutputDatadogCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogCompression);
 /** @internal */
 export const OutputDatadogCompression$outboundSchema: z.ZodType<
-  OutputDatadogCompression,
+  string,
   z.ZodTypeDef,
   OutputDatadogCompression
-> = z.union([
-  z.nativeEnum(OutputDatadogCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogCompression);
 
 /** @internal */
 export const OutputDatadogQueueFullBehavior$inboundSchema: z.ZodType<
   OutputDatadogQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatadogQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatadogQueueFullBehavior);
 /** @internal */
 export const OutputDatadogQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputDatadogQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputDatadogQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputDatadogQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatadogQueueFullBehavior);
 
 /** @internal */
 export const OutputDatadogPqControls$inboundSchema: z.ZodType<

package/src/models/outputdataset.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";
 
@@ -426,20 +422,13 @@ export const OutputDatasetSeverity$inboundSchema: z.ZodType<
   OutputDatasetSeverity,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetSeverity),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetSeverity);
 /** @internal */
 export const OutputDatasetSeverity$outboundSchema: z.ZodType<
-  OutputDatasetSeverity,
+  string,
   z.ZodTypeDef,
   OutputDatasetSeverity
-> = z.union([
-  z.nativeEnum(OutputDatasetSeverity),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetSeverity);
 
 /** @internal */
 export const OutputDatasetResponseRetrySetting$inboundSchema: z.ZodType<
@@ -546,20 +535,13 @@ export const DataSetSite$inboundSchema: z.ZodType<
   DataSetSite,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(DataSetSite),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(DataSetSite);
 /** @internal */
 export const DataSetSite$outboundSchema: z.ZodType<
-  DataSetSite,
+  string,
   z.ZodTypeDef,
   DataSetSite
-> = z.union([
-  z.nativeEnum(DataSetSite),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(DataSetSite);
 
 /** @internal */
 export const OutputDatasetExtraHttpHeader$inboundSchema: z.ZodType<
@@ -610,120 +592,78 @@ export const OutputDatasetFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputDatasetFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetFailedRequestLoggingMode);
 /** @internal */
 export const OutputDatasetFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputDatasetFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputDatasetFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputDatasetFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputDatasetBackpressureBehavior$inboundSchema: z.ZodType<
   OutputDatasetBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetBackpressureBehavior);
 /** @internal */
 export const OutputDatasetBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputDatasetBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputDatasetBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputDatasetBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetBackpressureBehavior);
 
 /** @internal */
 export const OutputDatasetAuthenticationMethod$inboundSchema: z.ZodType<
   OutputDatasetAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetAuthenticationMethod);
 /** @internal */
 export const OutputDatasetAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputDatasetAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputDatasetAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputDatasetAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetAuthenticationMethod);
 
 /** @internal */
 export const OutputDatasetMode$inboundSchema: z.ZodType<
   OutputDatasetMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetMode);
 /** @internal */
 export const OutputDatasetMode$outboundSchema: z.ZodType<
-  OutputDatasetMode,
+  string,
   z.ZodTypeDef,
   OutputDatasetMode
-> = z.union([
-  z.nativeEnum(OutputDatasetMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetMode);
 
 /** @internal */
 export const OutputDatasetCompression$inboundSchema: z.ZodType<
   OutputDatasetCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetCompression);
 /** @internal */
 export const OutputDatasetCompression$outboundSchema: z.ZodType<
-  OutputDatasetCompression,
+  string,
   z.ZodTypeDef,
   OutputDatasetCompression
-> = z.union([
-  z.nativeEnum(OutputDatasetCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetCompression);
 
 /** @internal */
 export const OutputDatasetQueueFullBehavior$inboundSchema: z.ZodType<
   OutputDatasetQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDatasetQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDatasetQueueFullBehavior);
 /** @internal */
 export const OutputDatasetQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputDatasetQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputDatasetQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputDatasetQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDatasetQueueFullBehavior);
 
 /** @internal */
 export const OutputDatasetPqControls$inboundSchema: z.ZodType<

package/src/models/outputdiskspool.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";
 
@@ -91,20 +87,13 @@ export const OutputDiskSpoolCompression$inboundSchema: z.ZodType<
   OutputDiskSpoolCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputDiskSpoolCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputDiskSpoolCompression);
 /** @internal */
 export const OutputDiskSpoolCompression$outboundSchema: z.ZodType<
-  OutputDiskSpoolCompression,
+  string,
   z.ZodTypeDef,
   OutputDiskSpoolCompression
-> = z.union([
-  z.nativeEnum(OutputDiskSpoolCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputDiskSpoolCompression);
 
 /** @internal */
 export const OutputDiskSpool$inboundSchema: z.ZodType<