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

package/src/models/outputstatsdext.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";
 
@@ -246,100 +242,65 @@ export const OutputStatsdExtDestinationProtocol$inboundSchema: z.ZodType<
   OutputStatsdExtDestinationProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtDestinationProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtDestinationProtocol);
 /** @internal */
 export const OutputStatsdExtDestinationProtocol$outboundSchema: z.ZodType<
-  OutputStatsdExtDestinationProtocol,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtDestinationProtocol
-> = z.union([
-  z.nativeEnum(OutputStatsdExtDestinationProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtDestinationProtocol);
 
 /** @internal */
 export const OutputStatsdExtBackpressureBehavior$inboundSchema: z.ZodType<
   OutputStatsdExtBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtBackpressureBehavior);
 /** @internal */
 export const OutputStatsdExtBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputStatsdExtBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputStatsdExtBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtBackpressureBehavior);
 
 /** @internal */
 export const OutputStatsdExtMode$inboundSchema: z.ZodType<
   OutputStatsdExtMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtMode);
 /** @internal */
 export const OutputStatsdExtMode$outboundSchema: z.ZodType<
-  OutputStatsdExtMode,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtMode
-> = z.union([
-  z.nativeEnum(OutputStatsdExtMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtMode);
 
 /** @internal */
 export const OutputStatsdExtCompression$inboundSchema: z.ZodType<
   OutputStatsdExtCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtCompression);
 /** @internal */
 export const OutputStatsdExtCompression$outboundSchema: z.ZodType<
-  OutputStatsdExtCompression,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtCompression
-> = z.union([
-  z.nativeEnum(OutputStatsdExtCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtCompression);
 
 /** @internal */
 export const OutputStatsdExtQueueFullBehavior$inboundSchema: z.ZodType<
   OutputStatsdExtQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputStatsdExtQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputStatsdExtQueueFullBehavior);
 /** @internal */
 export const OutputStatsdExtQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputStatsdExtQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputStatsdExtQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputStatsdExtQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputStatsdExtQueueFullBehavior);
 
 /** @internal */
 export const OutputStatsdExtPqControls$inboundSchema: z.ZodType<

package/src/models/outputsumologic.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";
 
@@ -355,20 +351,13 @@ export const OutputSumoLogicDataFormat$inboundSchema: z.ZodType<
   OutputSumoLogicDataFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicDataFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicDataFormat);
 /** @internal */
 export const OutputSumoLogicDataFormat$outboundSchema: z.ZodType<
-  OutputSumoLogicDataFormat,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicDataFormat
-> = z.union([
-  z.nativeEnum(OutputSumoLogicDataFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicDataFormat);
 
 /** @internal */
 export const OutputSumoLogicExtraHttpHeader$inboundSchema: z.ZodType<
@@ -419,20 +408,13 @@ export const OutputSumoLogicFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputSumoLogicFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicFailedRequestLoggingMode);
 /** @internal */
 export const OutputSumoLogicFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputSumoLogicFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputSumoLogicFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputSumoLogicResponseRetrySetting$inboundSchema: z.ZodType<
@@ -541,80 +523,52 @@ export const OutputSumoLogicBackpressureBehavior$inboundSchema: z.ZodType<
   OutputSumoLogicBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicBackpressureBehavior);
 /** @internal */
 export const OutputSumoLogicBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputSumoLogicBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputSumoLogicBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicBackpressureBehavior);
 
 /** @internal */
 export const OutputSumoLogicMode$inboundSchema: z.ZodType<
   OutputSumoLogicMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicMode);
 /** @internal */
 export const OutputSumoLogicMode$outboundSchema: z.ZodType<
-  OutputSumoLogicMode,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicMode
-> = z.union([
-  z.nativeEnum(OutputSumoLogicMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicMode);
 
 /** @internal */
 export const OutputSumoLogicCompression$inboundSchema: z.ZodType<
   OutputSumoLogicCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicCompression);
 /** @internal */
 export const OutputSumoLogicCompression$outboundSchema: z.ZodType<
-  OutputSumoLogicCompression,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicCompression
-> = z.union([
-  z.nativeEnum(OutputSumoLogicCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicCompression);
 
 /** @internal */
 export const OutputSumoLogicQueueFullBehavior$inboundSchema: z.ZodType<
   OutputSumoLogicQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSumoLogicQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSumoLogicQueueFullBehavior);
 /** @internal */
 export const OutputSumoLogicQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputSumoLogicQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputSumoLogicQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputSumoLogicQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSumoLogicQueueFullBehavior);
 
 /** @internal */
 export const OutputSumoLogicPqControls$inboundSchema: z.ZodType<

package/src/models/outputsyslog.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";
 
@@ -499,120 +495,78 @@ export const OutputSyslogProtocol$inboundSchema: z.ZodType<
   OutputSyslogProtocol,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogProtocol),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogProtocol);
 /** @internal */
 export const OutputSyslogProtocol$outboundSchema: z.ZodType<
-  OutputSyslogProtocol,
+  string,
   z.ZodTypeDef,
   OutputSyslogProtocol
-> = z.union([
-  z.nativeEnum(OutputSyslogProtocol),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogProtocol);
 
 /** @internal */
 export const Facility$inboundSchema: z.ZodType<
   Facility,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(Facility),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(Facility);
 /** @internal */
 export const Facility$outboundSchema: z.ZodType<
-  Facility,
+  number,
   z.ZodTypeDef,
   Facility
-> = z.union([
-  z.nativeEnum(Facility),
-  z.number().and(z.custom<Unrecognized<number>>()),
-]);
+> = openEnums.outboundSchemaInt(Facility);
 
 /** @internal */
 export const OutputSyslogSeverity$inboundSchema: z.ZodType<
   OutputSyslogSeverity,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogSeverity),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(OutputSyslogSeverity);
 /** @internal */
 export const OutputSyslogSeverity$outboundSchema: z.ZodType<
-  OutputSyslogSeverity,
+  number,
   z.ZodTypeDef,
   OutputSyslogSeverity
-> = z.union([
-  z.nativeEnum(OutputSyslogSeverity),
-  z.number().and(z.custom<Unrecognized<number>>()),
-]);
+> = openEnums.outboundSchemaInt(OutputSyslogSeverity);
 
 /** @internal */
 export const OutputSyslogMessageFormat$inboundSchema: z.ZodType<
   OutputSyslogMessageFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMessageFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMessageFormat);
 /** @internal */
 export const OutputSyslogMessageFormat$outboundSchema: z.ZodType<
-  OutputSyslogMessageFormat,
+  string,
   z.ZodTypeDef,
   OutputSyslogMessageFormat
-> = z.union([
-  z.nativeEnum(OutputSyslogMessageFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMessageFormat);
 
 /** @internal */
 export const TimestampFormat$inboundSchema: z.ZodType<
   TimestampFormat,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TimestampFormat),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TimestampFormat);
 /** @internal */
 export const TimestampFormat$outboundSchema: z.ZodType<
-  TimestampFormat,
+  string,
   z.ZodTypeDef,
   TimestampFormat
-> = z.union([
-  z.nativeEnum(TimestampFormat),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(TimestampFormat);
 
 /** @internal */
 export const OutputSyslogTLS$inboundSchema: z.ZodType<
   OutputSyslogTLS,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogTLS),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogTLS);
 /** @internal */
 export const OutputSyslogTLS$outboundSchema: z.ZodType<
-  OutputSyslogTLS,
+  string,
   z.ZodTypeDef,
   OutputSyslogTLS
-> = z.union([
-  z.nativeEnum(OutputSyslogTLS),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogTLS);
 
 /** @internal */
 export const OutputSyslogHost$inboundSchema: z.ZodType<
@@ -670,40 +624,26 @@ export const OutputSyslogMinimumTLSVersion$inboundSchema: z.ZodType<
   OutputSyslogMinimumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMinimumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMinimumTLSVersion);
 /** @internal */
 export const OutputSyslogMinimumTLSVersion$outboundSchema: z.ZodType<
-  OutputSyslogMinimumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputSyslogMinimumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputSyslogMinimumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMinimumTLSVersion);
 
 /** @internal */
 export const OutputSyslogMaximumTLSVersion$inboundSchema: z.ZodType<
   OutputSyslogMaximumTLSVersion,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMaximumTLSVersion),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMaximumTLSVersion);
 /** @internal */
 export const OutputSyslogMaximumTLSVersion$outboundSchema: z.ZodType<
-  OutputSyslogMaximumTLSVersion,
+  string,
   z.ZodTypeDef,
   OutputSyslogMaximumTLSVersion
-> = z.union([
-  z.nativeEnum(OutputSyslogMaximumTLSVersion),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMaximumTLSVersion);
 
 /** @internal */
 export const OutputSyslogTLSSettingsClientSide$inboundSchema: z.ZodType<
@@ -778,80 +718,52 @@ export const OutputSyslogBackpressureBehavior$inboundSchema: z.ZodType<
   OutputSyslogBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogBackpressureBehavior);
 /** @internal */
 export const OutputSyslogBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputSyslogBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputSyslogBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputSyslogBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogBackpressureBehavior);
 
 /** @internal */
 export const OutputSyslogMode$inboundSchema: z.ZodType<
   OutputSyslogMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogMode);
 /** @internal */
 export const OutputSyslogMode$outboundSchema: z.ZodType<
-  OutputSyslogMode,
+  string,
   z.ZodTypeDef,
   OutputSyslogMode
-> = z.union([
-  z.nativeEnum(OutputSyslogMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogMode);
 
 /** @internal */
 export const OutputSyslogCompression$inboundSchema: z.ZodType<
   OutputSyslogCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogCompression);
 /** @internal */
 export const OutputSyslogCompression$outboundSchema: z.ZodType<
-  OutputSyslogCompression,
+  string,
   z.ZodTypeDef,
   OutputSyslogCompression
-> = z.union([
-  z.nativeEnum(OutputSyslogCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogCompression);
 
 /** @internal */
 export const OutputSyslogQueueFullBehavior$inboundSchema: z.ZodType<
   OutputSyslogQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputSyslogQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputSyslogQueueFullBehavior);
 /** @internal */
 export const OutputSyslogQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputSyslogQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputSyslogQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputSyslogQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputSyslogQueueFullBehavior);
 
 /** @internal */
 export const OutputSyslogPqControls$inboundSchema: z.ZodType<