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

package/src/models/outputxsiam.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";
 
@@ -410,40 +406,26 @@ export const OutputXsiamFailedRequestLoggingMode$inboundSchema: z.ZodType<
   OutputXsiamFailedRequestLoggingMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamFailedRequestLoggingMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamFailedRequestLoggingMode);
 /** @internal */
 export const OutputXsiamFailedRequestLoggingMode$outboundSchema: z.ZodType<
-  OutputXsiamFailedRequestLoggingMode,
+  string,
   z.ZodTypeDef,
   OutputXsiamFailedRequestLoggingMode
-> = z.union([
-  z.nativeEnum(OutputXsiamFailedRequestLoggingMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamFailedRequestLoggingMode);
 
 /** @internal */
 export const OutputXsiamAuthenticationMethod$inboundSchema: z.ZodType<
   OutputXsiamAuthenticationMethod,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamAuthenticationMethod),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamAuthenticationMethod);
 /** @internal */
 export const OutputXsiamAuthenticationMethod$outboundSchema: z.ZodType<
-  OutputXsiamAuthenticationMethod,
+  string,
   z.ZodTypeDef,
   OutputXsiamAuthenticationMethod
-> = z.union([
-  z.nativeEnum(OutputXsiamAuthenticationMethod),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamAuthenticationMethod);
 
 /** @internal */
 export const OutputXsiamResponseRetrySetting$inboundSchema: z.ZodType<
@@ -550,20 +532,13 @@ export const OutputXsiamBackpressureBehavior$inboundSchema: z.ZodType<
   OutputXsiamBackpressureBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamBackpressureBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamBackpressureBehavior);
 /** @internal */
 export const OutputXsiamBackpressureBehavior$outboundSchema: z.ZodType<
-  OutputXsiamBackpressureBehavior,
+  string,
   z.ZodTypeDef,
   OutputXsiamBackpressureBehavior
-> = z.union([
-  z.nativeEnum(OutputXsiamBackpressureBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamBackpressureBehavior);
 
 /** @internal */
 export const OutputXsiamUrl$inboundSchema: z.ZodType<
@@ -608,60 +583,39 @@ export const OutputXsiamMode$inboundSchema: z.ZodType<
   OutputXsiamMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamMode);
 /** @internal */
 export const OutputXsiamMode$outboundSchema: z.ZodType<
-  OutputXsiamMode,
+  string,
   z.ZodTypeDef,
   OutputXsiamMode
-> = z.union([
-  z.nativeEnum(OutputXsiamMode),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamMode);
 
 /** @internal */
 export const OutputXsiamCompression$inboundSchema: z.ZodType<
   OutputXsiamCompression,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamCompression),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamCompression);
 /** @internal */
 export const OutputXsiamCompression$outboundSchema: z.ZodType<
-  OutputXsiamCompression,
+  string,
   z.ZodTypeDef,
   OutputXsiamCompression
-> = z.union([
-  z.nativeEnum(OutputXsiamCompression),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamCompression);
 
 /** @internal */
 export const OutputXsiamQueueFullBehavior$inboundSchema: z.ZodType<
   OutputXsiamQueueFullBehavior,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(OutputXsiamQueueFullBehavior),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(OutputXsiamQueueFullBehavior);
 /** @internal */
 export const OutputXsiamQueueFullBehavior$outboundSchema: z.ZodType<
-  OutputXsiamQueueFullBehavior,
+  string,
   z.ZodTypeDef,
   OutputXsiamQueueFullBehavior
-> = z.union([
-  z.nativeEnum(OutputXsiamQueueFullBehavior),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(OutputXsiamQueueFullBehavior);
 
 /** @internal */
 export const OutputXsiamPqControls$inboundSchema: z.ZodType<

package/src/models/productscore.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { OpenEnum, Unrecognized } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const ProductsCore = {
   Stream: "stream",
@@ -13,10 +14,7 @@ export type ProductsCore = OpenEnum<typeof ProductsCore>;
 
 /** @internal */
 export const ProductsCore$outboundSchema: z.ZodType<
-  ProductsCore,
+  string,
   z.ZodTypeDef,
   ProductsCore
-> = z.union([
-  z.nativeEnum(ProductsCore),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(ProductsCore);

package/src/models/rbacresource.ts

@@ -3,11 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import {
-  catchUnrecognizedEnum,
-  OpenEnum,
-  Unrecognized,
-} from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const RbacResource = {
   Groups: "groups",
@@ -25,17 +22,10 @@ export const RbacResource$inboundSchema: z.ZodType<
   RbacResource,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RbacResource),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RbacResource);
 /** @internal */
 export const RbacResource$outboundSchema: z.ZodType<
-  RbacResource,
+  string,
   z.ZodTypeDef,
   RbacResource
-> = z.union([
-  z.nativeEnum(RbacResource),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(RbacResource);

package/src/models/runnablejobcollection.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, ClosedEnum, OpenEnum } 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";
 
@@ -384,11 +385,7 @@ export const RunnableJobCollectionJobType$inboundSchema: z.ZodType<
   RunnableJobCollectionJobType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RunnableJobCollectionJobType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RunnableJobCollectionJobType);
 
 /** @internal */
 export const RunnableJobCollectionRunType$inboundSchema: z.ZodNativeEnum<
@@ -526,11 +523,7 @@ export const InputType$inboundSchema: z.ZodType<
   InputType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(InputType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(InputType);
 
 /** @internal */
 export const RunnableJobCollectionPreprocess$inboundSchema: z.ZodType<
@@ -607,33 +600,21 @@ export const RunnableJobCollectionLogLevel$inboundSchema: z.ZodType<
   RunnableJobCollectionLogLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RunnableJobCollectionLogLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RunnableJobCollectionLogLevel);
 
 /** @internal */
 export const RunnableJobCollectionMode$inboundSchema: z.ZodType<
   RunnableJobCollectionMode,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RunnableJobCollectionMode),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RunnableJobCollectionMode);
 
 /** @internal */
 export const TimeRange$inboundSchema: z.ZodType<
   TimeRange,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(TimeRange),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(TimeRange);
 
 /** @internal */
 export const RunnableJobCollectionTimeWarning$inboundSchema: z.ZodType<
@@ -657,11 +638,7 @@ export const WhereToCapture$inboundSchema: z.ZodType<
   WhereToCapture,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(WhereToCapture),
-    z.number().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchemaInt(WhereToCapture);
 
 /** @internal */
 export const CaptureSettings$inboundSchema: z.ZodType<
@@ -671,7 +648,7 @@ export const CaptureSettings$inboundSchema: z.ZodType<
 > = z.object({
   duration: z.number().default(60),
   maxEvents: z.number().default(100),
-  level: WhereToCapture$inboundSchema,
+  level: WhereToCapture$inboundSchema.default(0),
 });
 
 export function captureSettingsFromJSON(

package/src/models/runnablejobexecutor.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, ClosedEnum, OpenEnum } 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";
 
@@ -219,11 +220,7 @@ export const RunnableJobExecutorJobType$inboundSchema: z.ZodType<
   RunnableJobExecutorJobType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RunnableJobExecutorJobType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RunnableJobExecutorJobType);
 
 /** @internal */
 export const RunnableJobExecutorType$inboundSchema: z.ZodNativeEnum<
@@ -352,11 +349,7 @@ export const RunnableJobExecutorLogLevel$inboundSchema: z.ZodType<
   RunnableJobExecutorLogLevel,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RunnableJobExecutorLogLevel),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RunnableJobExecutorLogLevel);
 
 /** @internal */
 export const RunnableJobExecutorRun$inboundSchema: z.ZodType<

package/src/models/runnablejobscheduledsearch.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, ClosedEnum, OpenEnum } 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";
 
@@ -171,11 +172,7 @@ export const RunnableJobScheduledSearchJobType$inboundSchema: z.ZodType<
   RunnableJobScheduledSearchJobType,
   z.ZodTypeDef,
   unknown
-> = z
-  .union([
-    z.nativeEnum(RunnableJobScheduledSearchJobType),
-    z.string().transform(catchUnrecognizedEnum),
-  ]);
+> = openEnums.inboundSchema(RunnableJobScheduledSearchJobType);
 
 /** @internal */
 export const RunnableJobScheduledSearchType$inboundSchema: z.ZodNativeEnum<

package/src/models/workertypes.ts

@@ -3,7 +3,8 @@
  */
 
 import * as z from "zod/v3";
-import { OpenEnum, Unrecognized } from "../types/enums.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export const WorkerTypes = {
   Worker: "worker",
@@ -13,10 +14,7 @@ export type WorkerTypes = OpenEnum<typeof WorkerTypes>;
 
 /** @internal */
 export const WorkerTypes$outboundSchema: z.ZodType<
-  WorkerTypes,
+  string,
   z.ZodTypeDef,
   WorkerTypes
-> = z.union([
-  z.nativeEnum(WorkerTypes),
-  z.string().and(z.custom<Unrecognized<string>>()),
-]);
+> = openEnums.outboundSchema(WorkerTypes);

package/src/types/enums.ts

@@ -2,15 +2,64 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import * as z from "zod/v3";
+
 declare const __brand: unique symbol;
 export type Unrecognized<T> = T & { [__brand]: "unrecognized" };
+export type ClosedEnum<T extends Readonly<Record<string, string | number>>> =
+  T[keyof T];
+export type OpenEnum<T extends Readonly<Record<string, string | number>>> =
+  | T[keyof T]
+  | Unrecognized<T[keyof T] extends number ? number : string>;
 
-export function catchUnrecognizedEnum<T>(value: T): Unrecognized<T> {
+function unrecognized<T>(value: T): Unrecognized<T> {
+  unrecognizedCount++;
   return value as Unrecognized<T>;
 }
 
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-export type ClosedEnum<T> = T[keyof T];
-export type OpenEnum<T> =
-  | Prettify<T[keyof T]>
-  | Unrecognized<T[keyof T] extends number ? number : string>;
+let unrecognizedCount = 0;
+let refCount = 0;
+export function unrecognizedCounter() {
+  refCount++;
+  const start = unrecognizedCount;
+  return {
+    count: () => {
+      const count = unrecognizedCount - start;
+      if (--refCount === 0) unrecognizedCount = 0;
+      return count;
+    },
+  };
+}
+
+export function inboundSchema<T extends Record<string, string>>(
+  enumObj: T,
+): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+  const options = Object.values(enumObj);
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.string().transform(x => unrecognized(x)),
+  ] as any);
+}
+
+export function inboundSchemaInt<T extends Record<string, number | string>>(
+  enumObj: T,
+): z.ZodType<OpenEnum<T>, z.ZodTypeDef, unknown> {
+  // For numeric enums, Object.values returns both numbers and string keys
+  const options = Object.values(enumObj).filter(v => typeof v === "number");
+  return z.union([
+    ...options.map(x => z.literal(x)),
+    z.number().int().transform(x => unrecognized(x)),
+  ] as any);
+}
+
+export function outboundSchema<T extends Record<string, string>>(
+  _: T,
+): z.ZodType<string, z.ZodTypeDef, OpenEnum<T>> {
+  return z.string() as any;
+}
+
+export function outboundSchemaInt<T extends Record<string, number | string>>(
+  _: T,
+): z.ZodType<number, z.ZodTypeDef, OpenEnum<T>> {
+  return z.number().int() as any;
+}

package/src/types/index.ts

@@ -3,7 +3,6 @@
  */
 
 export { blobLikeSchema, isBlobLike } from "./blobs.js";
-export { catchUnrecognizedEnum } from "./enums.js";
 export type { ClosedEnum, OpenEnum, Unrecognized } from "./enums.js";
 export type { Result } from "./fp.js";
 export type { PageIterator, Paginator } from "./operations.js";