cribl-control-plane 0.5.0-beta.12 → 0.5.0-beta.14

package/src/models/collectorcribllake.ts

@@ -5,17 +5,23 @@
 import * as z from "zod/v3";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  CriblLakeCollectorConf,
+  CriblLakeCollectorConf$inboundSchema,
+  CriblLakeCollectorConf$Outbound,
+  CriblLakeCollectorConf$outboundSchema,
+} from "./cribllakecollectorconf.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+/**
+ * CriblLake collector configuration
+ */
 export type CollectorCriblLake = {
   /**
-   * Collector type: cribl_lake
+   * Collector type
    */
   type: "cribl_lake";
-  /**
-   * Lake dataset to collect data from.
-   */
-  dataset: string;
+  conf: CriblLakeCollectorConf;
 };
 
 /** @internal */
@@ -25,12 +31,12 @@ export const CollectorCriblLake$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: z.literal("cribl_lake"),
-  dataset: z.string(),
+  conf: CriblLakeCollectorConf$inboundSchema,
 });
 /** @internal */
 export type CollectorCriblLake$Outbound = {
   type: "cribl_lake";
-  dataset: string;
+  conf: CriblLakeCollectorConf$Outbound;
 };
 
 /** @internal */
@@ -40,7 +46,7 @@ export const CollectorCriblLake$outboundSchema: z.ZodType<
   CollectorCriblLake
 > = z.object({
   type: z.literal("cribl_lake"),
-  dataset: z.string(),
+  conf: CriblLakeCollectorConf$outboundSchema,
 });
 
 export function collectorCriblLakeToJSON(

package/src/models/collectordatabase.ts

@@ -3,149 +3,27 @@
  */
 
 import * as z from "zod/v3";
-import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import {
+  DatabaseCollectorConf,
+  DatabaseCollectorConf$inboundSchema,
+  DatabaseCollectorConf$Outbound,
+  DatabaseCollectorConf$outboundSchema,
+} from "./databasecollectorconf.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export const CollectorDatabaseHiddenDefaultBreakers = {
-  Cribl: "Cribl",
-} as const;
-export type CollectorDatabaseHiddenDefaultBreakers = OpenEnum<
-  typeof CollectorDatabaseHiddenDefaultBreakers
->;
-
-export type CollectorDatabaseStateTracking = {
-  /**
-   * Enable tracking of collection progress between consecutive scheduled executions.
-   */
-  enabled?: boolean | undefined;
-};
-
-export type CollectorDatabaseScheduling = {
-  stateTracking?: CollectorDatabaseStateTracking | undefined;
-};
-
+/**
+ * Database collector configuration
+ */
 export type CollectorDatabase = {
   /**
-   * Collector type: database
+   * Collector type
    */
   type: "database";
-  /**
-   * Select an existing Connection, or go to Knowledge > Database Connections to add one
-   */
-  connectionId: string;
-  /**
-   * An expression that resolves to the query string for selecting data from the database. Has access to the special ${earliest} and ${latest} variables, which will resolve to the Collector run's start and end time.
-   */
-  query: string;
-  /**
-   * Enforces a basic query validation that allows only a single 'select' statement. Disable for more complex queries or when using semicolons. Caution: Disabling query validation allows DDL and DML statements to be executed, which could be destructive to your database.
-   */
-  queryValidationEnabled?: boolean | undefined;
-  defaultBreakers?: CollectorDatabaseHiddenDefaultBreakers | undefined;
-  scheduling?: CollectorDatabaseScheduling | undefined;
-};
-
-/** @internal */
-export const CollectorDatabaseHiddenDefaultBreakers$inboundSchema: z.ZodType<
-  CollectorDatabaseHiddenDefaultBreakers,
-  z.ZodTypeDef,
-  unknown
-> = openEnums.inboundSchema(CollectorDatabaseHiddenDefaultBreakers);
-/** @internal */
-export const CollectorDatabaseHiddenDefaultBreakers$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  CollectorDatabaseHiddenDefaultBreakers
-> = openEnums.outboundSchema(CollectorDatabaseHiddenDefaultBreakers);
-
-/** @internal */
-export const CollectorDatabaseStateTracking$inboundSchema: z.ZodType<
-  CollectorDatabaseStateTracking,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  enabled: z.boolean().optional(),
-});
-/** @internal */
-export type CollectorDatabaseStateTracking$Outbound = {
-  enabled?: boolean | undefined;
-};
-
-/** @internal */
-export const CollectorDatabaseStateTracking$outboundSchema: z.ZodType<
-  CollectorDatabaseStateTracking$Outbound,
-  z.ZodTypeDef,
-  CollectorDatabaseStateTracking
-> = z.object({
-  enabled: z.boolean().optional(),
-});
-
-export function collectorDatabaseStateTrackingToJSON(
-  collectorDatabaseStateTracking: CollectorDatabaseStateTracking,
-): string {
-  return JSON.stringify(
-    CollectorDatabaseStateTracking$outboundSchema.parse(
-      collectorDatabaseStateTracking,
-    ),
-  );
-}
-export function collectorDatabaseStateTrackingFromJSON(
-  jsonString: string,
-): SafeParseResult<CollectorDatabaseStateTracking, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CollectorDatabaseStateTracking$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CollectorDatabaseStateTracking' from JSON`,
-  );
-}
-
-/** @internal */
-export const CollectorDatabaseScheduling$inboundSchema: z.ZodType<
-  CollectorDatabaseScheduling,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  stateTracking: z.lazy(() => CollectorDatabaseStateTracking$inboundSchema)
-    .optional(),
-});
-/** @internal */
-export type CollectorDatabaseScheduling$Outbound = {
-  stateTracking?: CollectorDatabaseStateTracking$Outbound | undefined;
+  conf: DatabaseCollectorConf;
 };
 
-/** @internal */
-export const CollectorDatabaseScheduling$outboundSchema: z.ZodType<
-  CollectorDatabaseScheduling$Outbound,
-  z.ZodTypeDef,
-  CollectorDatabaseScheduling
-> = z.object({
-  stateTracking: z.lazy(() => CollectorDatabaseStateTracking$outboundSchema)
-    .optional(),
-});
-
-export function collectorDatabaseSchedulingToJSON(
-  collectorDatabaseScheduling: CollectorDatabaseScheduling,
-): string {
-  return JSON.stringify(
-    CollectorDatabaseScheduling$outboundSchema.parse(
-      collectorDatabaseScheduling,
-    ),
-  );
-}
-export function collectorDatabaseSchedulingFromJSON(
-  jsonString: string,
-): SafeParseResult<CollectorDatabaseScheduling, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CollectorDatabaseScheduling$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CollectorDatabaseScheduling' from JSON`,
-  );
-}
-
 /** @internal */
 export const CollectorDatabase$inboundSchema: z.ZodType<
   CollectorDatabase,
@@ -153,26 +31,12 @@ export const CollectorDatabase$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: z.literal("database"),
-  connectionId: z.string(),
-  query: z.string(),
-  queryValidationEnabled: z.boolean().default(true),
-  defaultBreakers: CollectorDatabaseHiddenDefaultBreakers$inboundSchema
-    .optional(),
-  __scheduling: z.lazy(() => CollectorDatabaseScheduling$inboundSchema)
-    .optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "__scheduling": "scheduling",
-  });
+  conf: DatabaseCollectorConf$inboundSchema,
 });
 /** @internal */
 export type CollectorDatabase$Outbound = {
   type: "database";
-  connectionId: string;
-  query: string;
-  queryValidationEnabled: boolean;
-  defaultBreakers?: string | undefined;
-  __scheduling?: CollectorDatabaseScheduling$Outbound | undefined;
+  conf: DatabaseCollectorConf$Outbound;
 };
 
 /** @internal */
@@ -182,17 +46,7 @@ export const CollectorDatabase$outboundSchema: z.ZodType<
   CollectorDatabase
 > = z.object({
   type: z.literal("database"),
-  connectionId: z.string(),
-  query: z.string(),
-  queryValidationEnabled: z.boolean().default(true),
-  defaultBreakers: CollectorDatabaseHiddenDefaultBreakers$outboundSchema
-    .optional(),
-  scheduling: z.lazy(() => CollectorDatabaseScheduling$outboundSchema)
-    .optional(),
-}).transform((v) => {
-  return remap$(v, {
-    scheduling: "__scheduling",
-  });
+  conf: DatabaseCollectorConf$outboundSchema,
 });
 
 export function collectorDatabaseToJSON(

package/src/models/collectorfilesystem.ts

@@ -6,89 +6,24 @@ 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";
+import {
+  FilesystemCollectorConf,
+  FilesystemCollectorConf$inboundSchema,
+  FilesystemCollectorConf$Outbound,
+  FilesystemCollectorConf$outboundSchema,
+} from "./filesystemcollectorconf.js";
 
-export type CollectorFilesystemExtractor = {
-  /**
-   * A token from the template directory, such as epoch
-   */
-  key: string;
-  /**
-   * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields, such as {date: new Date(+value*1000)}
-   */
-  expression: string;
-};
-
+/**
+ * Filesystem collector configuration
+ */
 export type CollectorFilesystem = {
   /**
-   * Collector type: filesystem
+   * Collector type
    */
   type: "filesystem";
-  /**
-   * Select a predefined configuration (a Destination) to auto-populate Collector settings
-   */
-  outputName?: string | undefined;
-  /**
-   * The directory from which to collect data. Templating is supported, such as /myDir/${datacenter}/${host}/${app}/. Time-based tokens are also supported, such as /myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/.
-   */
-  path: string;
-  /**
-   * Allows using template tokens as context for expressions that enrich discovery results. For example, given a template /path/${epoch}, an extractor under key "epoch" with an expression {date: new Date(+value*1000)}, will enrich discovery results with a human readable "date" field.
-   */
-  extractors?: Array<CollectorFilesystemExtractor> | undefined;
-  /**
-   * Recurse through subdirectories
-   */
-  recurse?: boolean | undefined;
-  /**
-   * Maximum number of metadata files to batch before recording as results
-   */
-  maxBatchSize?: number | undefined;
-};
-
-/** @internal */
-export const CollectorFilesystemExtractor$inboundSchema: z.ZodType<
-  CollectorFilesystemExtractor,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  key: z.string(),
-  expression: z.string(),
-});
-/** @internal */
-export type CollectorFilesystemExtractor$Outbound = {
-  key: string;
-  expression: string;
+  conf: FilesystemCollectorConf;
 };
 
-/** @internal */
-export const CollectorFilesystemExtractor$outboundSchema: z.ZodType<
-  CollectorFilesystemExtractor$Outbound,
-  z.ZodTypeDef,
-  CollectorFilesystemExtractor
-> = z.object({
-  key: z.string(),
-  expression: z.string(),
-});
-
-export function collectorFilesystemExtractorToJSON(
-  collectorFilesystemExtractor: CollectorFilesystemExtractor,
-): string {
-  return JSON.stringify(
-    CollectorFilesystemExtractor$outboundSchema.parse(
-      collectorFilesystemExtractor,
-    ),
-  );
-}
-export function collectorFilesystemExtractorFromJSON(
-  jsonString: string,
-): SafeParseResult<CollectorFilesystemExtractor, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CollectorFilesystemExtractor$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CollectorFilesystemExtractor' from JSON`,
-  );
-}
-
 /** @internal */
 export const CollectorFilesystem$inboundSchema: z.ZodType<
   CollectorFilesystem,
@@ -96,21 +31,12 @@ export const CollectorFilesystem$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   type: z.literal("filesystem"),
-  outputName: z.string().optional(),
-  path: z.string(),
-  extractors: z.array(z.lazy(() => CollectorFilesystemExtractor$inboundSchema))
-    .optional(),
-  recurse: z.boolean().default(true),
-  maxBatchSize: z.number().default(10),
+  conf: FilesystemCollectorConf$inboundSchema,
 });
 /** @internal */
 export type CollectorFilesystem$Outbound = {
   type: "filesystem";
-  outputName?: string | undefined;
-  path: string;
-  extractors?: Array<CollectorFilesystemExtractor$Outbound> | undefined;
-  recurse: boolean;
-  maxBatchSize: number;
+  conf: FilesystemCollectorConf$Outbound;
 };
 
 /** @internal */
@@ -120,12 +46,7 @@ export const CollectorFilesystem$outboundSchema: z.ZodType<
   CollectorFilesystem
 > = z.object({
   type: z.literal("filesystem"),
-  outputName: z.string().optional(),
-  path: z.string(),
-  extractors: z.array(z.lazy(() => CollectorFilesystemExtractor$outboundSchema))
-    .optional(),
-  recurse: z.boolean().default(true),
-  maxBatchSize: z.number().default(10),
+  conf: FilesystemCollectorConf$outboundSchema,
 });
 
 export function collectorFilesystemToJSON(