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

package/src/models/runnablejobcollection.ts

@@ -4,8 +4,10 @@
 
 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 { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { CollectorConf, CollectorConf$inboundSchema } from "./collectorconf.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export const RunnableJobCollectionJobType = {
@@ -20,7 +22,7 @@ export type RunnableJobCollectionJobType = OpenEnum<
 export const RunnableJobCollectionRunType = {
   Collection: "collection",
 } as const;
-export type RunnableJobCollectionRunType = ClosedEnum<
+export type RunnableJobCollectionRunType = OpenEnum<
   typeof RunnableJobCollectionRunType
 >;
 
@@ -37,7 +39,7 @@ export const RunnableJobCollectionScheduleLogLevel = {
 /**
  * Level at which to set task logging
  */
-export type RunnableJobCollectionScheduleLogLevel = ClosedEnum<
+export type RunnableJobCollectionScheduleLogLevel = OpenEnum<
   typeof RunnableJobCollectionScheduleLogLevel
 >;
 
@@ -125,14 +127,15 @@ export type RunnableJobCollectionSchedule = {
   run?: RunnableJobCollectionRunSettings | undefined;
 };
 
-export type CollectorSpecificSettings = {};
-
 export type Collector = {
   /**
    * The type of collector to run
    */
   type: string;
-  conf: CollectorSpecificSettings;
+  /**
+   * Collector configuration
+   */
+  conf: CollectorConf;
   /**
    * Delete any files collected (where applicable)
    */
@@ -384,22 +387,21 @@ 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<
-  typeof RunnableJobCollectionRunType
-> = z.nativeEnum(RunnableJobCollectionRunType);
+export const RunnableJobCollectionRunType$inboundSchema: z.ZodType<
+  RunnableJobCollectionRunType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RunnableJobCollectionRunType);
 
 /** @internal */
-export const RunnableJobCollectionScheduleLogLevel$inboundSchema:
-  z.ZodNativeEnum<typeof RunnableJobCollectionScheduleLogLevel> = z.nativeEnum(
-    RunnableJobCollectionScheduleLogLevel,
-  );
+export const RunnableJobCollectionScheduleLogLevel$inboundSchema: z.ZodType<
+  RunnableJobCollectionScheduleLogLevel,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RunnableJobCollectionScheduleLogLevel);
 
 /** @internal */
 export const RunnableJobCollectionScheduleTimeWarning$inboundSchema: z.ZodType<
@@ -482,23 +484,6 @@ export function runnableJobCollectionScheduleFromJSON(
   );
 }
 
-/** @internal */
-export const CollectorSpecificSettings$inboundSchema: z.ZodType<
-  CollectorSpecificSettings,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
-
-export function collectorSpecificSettingsFromJSON(
-  jsonString: string,
-): SafeParseResult<CollectorSpecificSettings, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CollectorSpecificSettings$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CollectorSpecificSettings' from JSON`,
-  );
-}
-
 /** @internal */
 export const Collector$inboundSchema: z.ZodType<
   Collector,
@@ -506,7 +491,7 @@ export const Collector$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: z.string(),
-  conf: z.lazy(() => CollectorSpecificSettings$inboundSchema),
+  conf: CollectorConf$inboundSchema,
   destructive: z.boolean().default(false),
   encoding: z.string().optional(),
 });
@@ -526,11 +511,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 +588,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 +626,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 +636,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 { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -20,9 +21,7 @@ export type RunnableJobExecutorJobType = OpenEnum<
 export const RunnableJobExecutorType = {
   Collection: "collection",
 } as const;
-export type RunnableJobExecutorType = ClosedEnum<
-  typeof RunnableJobExecutorType
->;
+export type RunnableJobExecutorType = OpenEnum<typeof RunnableJobExecutorType>;
 
 /**
  * Level at which to set task logging
@@ -37,7 +36,7 @@ export const RunnableJobExecutorScheduleLogLevel = {
 /**
  * Level at which to set task logging
  */
-export type RunnableJobExecutorScheduleLogLevel = ClosedEnum<
+export type RunnableJobExecutorScheduleLogLevel = OpenEnum<
   typeof RunnableJobExecutorScheduleLogLevel
 >;
 
@@ -219,21 +218,21 @@ 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<
-  typeof RunnableJobExecutorType
-> = z.nativeEnum(RunnableJobExecutorType);
+export const RunnableJobExecutorType$inboundSchema: z.ZodType<
+  RunnableJobExecutorType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RunnableJobExecutorType);
 
 /** @internal */
-export const RunnableJobExecutorScheduleLogLevel$inboundSchema: z.ZodNativeEnum<
-  typeof RunnableJobExecutorScheduleLogLevel
-> = z.nativeEnum(RunnableJobExecutorScheduleLogLevel);
+export const RunnableJobExecutorScheduleLogLevel$inboundSchema: z.ZodType<
+  RunnableJobExecutorScheduleLogLevel,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RunnableJobExecutorScheduleLogLevel);
 
 /** @internal */
 export const RunnableJobExecutorTimeWarning$inboundSchema: z.ZodType<
@@ -352,11 +351,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 { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -20,7 +21,7 @@ export type RunnableJobScheduledSearchJobType = OpenEnum<
 export const RunnableJobScheduledSearchType = {
   Collection: "collection",
 } as const;
-export type RunnableJobScheduledSearchType = ClosedEnum<
+export type RunnableJobScheduledSearchType = OpenEnum<
   typeof RunnableJobScheduledSearchType
 >;
 
@@ -37,7 +38,7 @@ export const RunnableJobScheduledSearchLogLevel = {
 /**
  * Level at which to set task logging
  */
-export type RunnableJobScheduledSearchLogLevel = ClosedEnum<
+export type RunnableJobScheduledSearchLogLevel = OpenEnum<
   typeof RunnableJobScheduledSearchLogLevel
 >;
 
@@ -171,21 +172,21 @@ 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<
-  typeof RunnableJobScheduledSearchType
-> = z.nativeEnum(RunnableJobScheduledSearchType);
+export const RunnableJobScheduledSearchType$inboundSchema: z.ZodType<
+  RunnableJobScheduledSearchType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RunnableJobScheduledSearchType);
 
 /** @internal */
-export const RunnableJobScheduledSearchLogLevel$inboundSchema: z.ZodNativeEnum<
-  typeof RunnableJobScheduledSearchLogLevel
-> = z.nativeEnum(RunnableJobScheduledSearchLogLevel);
+export const RunnableJobScheduledSearchLogLevel$inboundSchema: z.ZodType<
+  RunnableJobScheduledSearchLogLevel,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RunnableJobScheduledSearchLogLevel);
 
 /** @internal */
 export const RunnableJobScheduledSearchTimeWarning$inboundSchema: z.ZodType<

package/src/models/snisettingsunion.ts

@@ -0,0 +1,121 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type SniSettings2 = {};
+
+export type SniSettings1 = {
+  disableSNIRouting: boolean;
+};
+
+export type SniSettingsUnion = SniSettings1 | SniSettings2;
+
+/** @internal */
+export const SniSettings2$inboundSchema: z.ZodType<
+  SniSettings2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type SniSettings2$Outbound = {};
+
+/** @internal */
+export const SniSettings2$outboundSchema: z.ZodType<
+  SniSettings2$Outbound,
+  z.ZodTypeDef,
+  SniSettings2
+> = z.object({});
+
+export function sniSettings2ToJSON(sniSettings2: SniSettings2): string {
+  return JSON.stringify(SniSettings2$outboundSchema.parse(sniSettings2));
+}
+export function sniSettings2FromJSON(
+  jsonString: string,
+): SafeParseResult<SniSettings2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SniSettings2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SniSettings2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SniSettings1$inboundSchema: z.ZodType<
+  SniSettings1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  disableSNIRouting: z.boolean(),
+});
+/** @internal */
+export type SniSettings1$Outbound = {
+  disableSNIRouting: boolean;
+};
+
+/** @internal */
+export const SniSettings1$outboundSchema: z.ZodType<
+  SniSettings1$Outbound,
+  z.ZodTypeDef,
+  SniSettings1
+> = z.object({
+  disableSNIRouting: z.boolean(),
+});
+
+export function sniSettings1ToJSON(sniSettings1: SniSettings1): string {
+  return JSON.stringify(SniSettings1$outboundSchema.parse(sniSettings1));
+}
+export function sniSettings1FromJSON(
+  jsonString: string,
+): SafeParseResult<SniSettings1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SniSettings1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SniSettings1' from JSON`,
+  );
+}
+
+/** @internal */
+export const SniSettingsUnion$inboundSchema: z.ZodType<
+  SniSettingsUnion,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => SniSettings1$inboundSchema),
+  z.lazy(() => SniSettings2$inboundSchema),
+]);
+/** @internal */
+export type SniSettingsUnion$Outbound =
+  | SniSettings1$Outbound
+  | SniSettings2$Outbound;
+
+/** @internal */
+export const SniSettingsUnion$outboundSchema: z.ZodType<
+  SniSettingsUnion$Outbound,
+  z.ZodTypeDef,
+  SniSettingsUnion
+> = z.union([
+  z.lazy(() => SniSettings1$outboundSchema),
+  z.lazy(() => SniSettings2$outboundSchema),
+]);
+
+export function sniSettingsUnionToJSON(
+  sniSettingsUnion: SniSettingsUnion,
+): string {
+  return JSON.stringify(
+    SniSettingsUnion$outboundSchema.parse(sniSettingsUnion),
+  );
+}
+export function sniSettingsUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<SniSettingsUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SniSettingsUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SniSettingsUnion' from JSON`,
+  );
+}