cribl-control-plane 0.5.0-rc.2 → 0.5.0-rc.4

package/src/models/collectorazureblob.ts

@@ -0,0 +1,223 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Enter authentication data directly, or select a secret referencing your auth data
+ */
+export const CollectorAzureBlobAuthenticationMethod = {
+  Manual: "manual",
+  Secret: "secret",
+  ClientSecret: "clientSecret",
+  ClientCert: "clientCert",
+} as const;
+/**
+ * Enter authentication data directly, or select a secret referencing your auth data
+ */
+export type CollectorAzureBlobAuthenticationMethod = OpenEnum<
+  typeof CollectorAzureBlobAuthenticationMethod
+>;
+
+export type CollectorAzureBlobExtractor = {
+  /**
+   * A token from the template path, such as epoch
+   */
+  key: string;
+  /**
+   * A JavaScript expression that accesses a corresponding <token> through the value variable and evaluates the token to populate event fields. Example: {date: new Date(+value*1000)}
+   */
+  expression: string;
+};
+
+export type CollectorAzureBlob = {
+  /**
+   * Collector type: azure_blob
+   */
+  type: "azure_blob";
+  /**
+   * An optional predefined Destination that will be used to auto-populate Collector settings
+   */
+  outputName?: string | undefined;
+  /**
+   * Enter authentication data directly, or select a secret referencing your auth data
+   */
+  authType?: CollectorAzureBlobAuthenticationMethod | undefined;
+  /**
+   * Container to collect from. This value can be a constant, or a JavaScript expression that can only be evaluated at init time. Example referencing a Global Variable: myBucket-${C.vars.myVar}
+   */
+  containerName: string;
+  /**
+   * The directory from which to collect data. Templating is supported, such as myDir/${datacenter}/${host}/${app}/. Time-based tokens are supported, such as myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/.
+   */
+  path?: string | undefined;
+  /**
+   * Extractors allow use of 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<CollectorAzureBlobExtractor> | undefined;
+  /**
+   * Recurse through subdirectories
+   */
+  recurse?: boolean | undefined;
+  /**
+   * Include Azure Blob metadata in collected events. In each event, metadata will be located at: __collectible.metadata.
+   */
+  includeMetadata?: boolean | undefined;
+  /**
+   * Include Azure Blob tags in collected events. In each event, tags will be located at: __collectible.tags. Disable this feature when using a Shared Access Signature Connection String, to prevent errors.
+   */
+  includeTags?: boolean | undefined;
+  /**
+   * Maximum number of metadata objects to batch before recording as results
+   */
+  maxBatchSize?: number | undefined;
+  /**
+   * Maximum file size for each Parquet chunk
+   */
+  parquetChunkSizeMB?: number | undefined;
+  /**
+   * The maximum time allowed for downloading a Parquet chunk. Processing will abort if a chunk cannot be downloaded within the time specified.
+   */
+  parquetChunkDownloadTimeout?: number | undefined;
+};
+
+/** @internal */
+export const CollectorAzureBlobAuthenticationMethod$inboundSchema: z.ZodType<
+  CollectorAzureBlobAuthenticationMethod,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectorAzureBlobAuthenticationMethod);
+/** @internal */
+export const CollectorAzureBlobAuthenticationMethod$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  CollectorAzureBlobAuthenticationMethod
+> = openEnums.outboundSchema(CollectorAzureBlobAuthenticationMethod);
+
+/** @internal */
+export const CollectorAzureBlobExtractor$inboundSchema: z.ZodType<
+  CollectorAzureBlobExtractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+/** @internal */
+export type CollectorAzureBlobExtractor$Outbound = {
+  key: string;
+  expression: string;
+};
+
+/** @internal */
+export const CollectorAzureBlobExtractor$outboundSchema: z.ZodType<
+  CollectorAzureBlobExtractor$Outbound,
+  z.ZodTypeDef,
+  CollectorAzureBlobExtractor
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function collectorAzureBlobExtractorToJSON(
+  collectorAzureBlobExtractor: CollectorAzureBlobExtractor,
+): string {
+  return JSON.stringify(
+    CollectorAzureBlobExtractor$outboundSchema.parse(
+      collectorAzureBlobExtractor,
+    ),
+  );
+}
+export function collectorAzureBlobExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorAzureBlobExtractor, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorAzureBlobExtractor$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorAzureBlobExtractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectorAzureBlob$inboundSchema: z.ZodType<
+  CollectorAzureBlob,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("azure_blob"),
+  outputName: z.string().optional(),
+  authType: CollectorAzureBlobAuthenticationMethod$inboundSchema.default(
+    "manual",
+  ),
+  containerName: z.string(),
+  path: z.string().optional(),
+  extractors: z.array(z.lazy(() => CollectorAzureBlobExtractor$inboundSchema))
+    .optional(),
+  recurse: z.boolean().default(true),
+  includeMetadata: z.boolean().default(true),
+  includeTags: z.boolean().default(true),
+  maxBatchSize: z.number().default(10),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+});
+/** @internal */
+export type CollectorAzureBlob$Outbound = {
+  type: "azure_blob";
+  outputName?: string | undefined;
+  authType: string;
+  containerName: string;
+  path?: string | undefined;
+  extractors?: Array<CollectorAzureBlobExtractor$Outbound> | undefined;
+  recurse: boolean;
+  includeMetadata: boolean;
+  includeTags: boolean;
+  maxBatchSize: number;
+  parquetChunkSizeMB: number;
+  parquetChunkDownloadTimeout: number;
+};
+
+/** @internal */
+export const CollectorAzureBlob$outboundSchema: z.ZodType<
+  CollectorAzureBlob$Outbound,
+  z.ZodTypeDef,
+  CollectorAzureBlob
+> = z.object({
+  type: z.literal("azure_blob"),
+  outputName: z.string().optional(),
+  authType: CollectorAzureBlobAuthenticationMethod$outboundSchema.default(
+    "manual",
+  ),
+  containerName: z.string(),
+  path: z.string().optional(),
+  extractors: z.array(z.lazy(() => CollectorAzureBlobExtractor$outboundSchema))
+    .optional(),
+  recurse: z.boolean().default(true),
+  includeMetadata: z.boolean().default(true),
+  includeTags: z.boolean().default(true),
+  maxBatchSize: z.number().default(10),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+});
+
+export function collectorAzureBlobToJSON(
+  collectorAzureBlob: CollectorAzureBlob,
+): string {
+  return JSON.stringify(
+    CollectorAzureBlob$outboundSchema.parse(collectorAzureBlob),
+  );
+}
+export function collectorAzureBlobFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorAzureBlob, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorAzureBlob$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorAzureBlob' from JSON`,
+  );
+}

package/src/models/collectorconf.ts

@@ -0,0 +1,144 @@
+/*
+ * 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 {
+  CollectorAzureBlob,
+  CollectorAzureBlob$inboundSchema,
+  CollectorAzureBlob$Outbound,
+  CollectorAzureBlob$outboundSchema,
+} from "./collectorazureblob.js";
+import {
+  CollectorCriblLake,
+  CollectorCriblLake$inboundSchema,
+  CollectorCriblLake$Outbound,
+  CollectorCriblLake$outboundSchema,
+} from "./collectorcribllake.js";
+import {
+  CollectorDatabase,
+  CollectorDatabase$inboundSchema,
+  CollectorDatabase$Outbound,
+  CollectorDatabase$outboundSchema,
+} from "./collectordatabase.js";
+import {
+  CollectorFilesystem,
+  CollectorFilesystem$inboundSchema,
+  CollectorFilesystem$Outbound,
+  CollectorFilesystem$outboundSchema,
+} from "./collectorfilesystem.js";
+import {
+  CollectorGoogleCloudStorage,
+  CollectorGoogleCloudStorage$inboundSchema,
+  CollectorGoogleCloudStorage$Outbound,
+  CollectorGoogleCloudStorage$outboundSchema,
+} from "./collectorgooglecloudstorage.js";
+import {
+  CollectorHealthCheck,
+  CollectorHealthCheck$inboundSchema,
+  CollectorHealthCheck$Outbound,
+  CollectorHealthCheck$outboundSchema,
+} from "./collectorhealthcheck.js";
+import {
+  CollectorRest,
+  CollectorRest$inboundSchema,
+  CollectorRest$Outbound,
+  CollectorRest$outboundSchema,
+} from "./collectorrest.js";
+import {
+  CollectorS3,
+  CollectorS3$inboundSchema,
+  CollectorS3$Outbound,
+  CollectorS3$outboundSchema,
+} from "./collectors3.js";
+import {
+  CollectorScript,
+  CollectorScript$inboundSchema,
+  CollectorScript$Outbound,
+  CollectorScript$outboundSchema,
+} from "./collectorscript.js";
+import {
+  CollectorSplunk,
+  CollectorSplunk$inboundSchema,
+  CollectorSplunk$Outbound,
+  CollectorSplunk$outboundSchema,
+} from "./collectorsplunk.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+/**
+ * Collector configuration
+ */
+export type CollectorConf =
+  | CollectorAzureBlob
+  | CollectorCriblLake
+  | CollectorDatabase
+  | CollectorFilesystem
+  | CollectorGoogleCloudStorage
+  | CollectorHealthCheck
+  | CollectorRest
+  | CollectorS3
+  | CollectorScript
+  | CollectorSplunk;
+
+/** @internal */
+export const CollectorConf$inboundSchema: z.ZodType<
+  CollectorConf,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  CollectorAzureBlob$inboundSchema,
+  CollectorCriblLake$inboundSchema,
+  CollectorDatabase$inboundSchema,
+  CollectorFilesystem$inboundSchema,
+  CollectorGoogleCloudStorage$inboundSchema,
+  CollectorHealthCheck$inboundSchema,
+  CollectorRest$inboundSchema,
+  CollectorS3$inboundSchema,
+  CollectorScript$inboundSchema,
+  CollectorSplunk$inboundSchema,
+]);
+/** @internal */
+export type CollectorConf$Outbound =
+  | CollectorAzureBlob$Outbound
+  | CollectorCriblLake$Outbound
+  | CollectorDatabase$Outbound
+  | CollectorFilesystem$Outbound
+  | CollectorGoogleCloudStorage$Outbound
+  | CollectorHealthCheck$Outbound
+  | CollectorRest$Outbound
+  | CollectorS3$Outbound
+  | CollectorScript$Outbound
+  | CollectorSplunk$Outbound;
+
+/** @internal */
+export const CollectorConf$outboundSchema: z.ZodType<
+  CollectorConf$Outbound,
+  z.ZodTypeDef,
+  CollectorConf
+> = z.union([
+  CollectorAzureBlob$outboundSchema,
+  CollectorCriblLake$outboundSchema,
+  CollectorDatabase$outboundSchema,
+  CollectorFilesystem$outboundSchema,
+  CollectorGoogleCloudStorage$outboundSchema,
+  CollectorHealthCheck$outboundSchema,
+  CollectorRest$outboundSchema,
+  CollectorS3$outboundSchema,
+  CollectorScript$outboundSchema,
+  CollectorSplunk$outboundSchema,
+]);
+
+export function collectorConfToJSON(collectorConf: CollectorConf): string {
+  return JSON.stringify(CollectorConf$outboundSchema.parse(collectorConf));
+}
+export function collectorConfFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorConf, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorConf$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorConf' from JSON`,
+  );
+}

package/src/models/collectorcribllake.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 CollectorCriblLake = {
+  /**
+   * Collector type: cribl_lake
+   */
+  type: "cribl_lake";
+  /**
+   * Lake dataset to collect data from.
+   */
+  dataset: string;
+};
+
+/** @internal */
+export const CollectorCriblLake$inboundSchema: z.ZodType<
+  CollectorCriblLake,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("cribl_lake"),
+  dataset: z.string(),
+});
+/** @internal */
+export type CollectorCriblLake$Outbound = {
+  type: "cribl_lake";
+  dataset: string;
+};
+
+/** @internal */
+export const CollectorCriblLake$outboundSchema: z.ZodType<
+  CollectorCriblLake$Outbound,
+  z.ZodTypeDef,
+  CollectorCriblLake
+> = z.object({
+  type: z.literal("cribl_lake"),
+  dataset: z.string(),
+});
+
+export function collectorCriblLakeToJSON(
+  collectorCriblLake: CollectorCriblLake,
+): string {
+  return JSON.stringify(
+    CollectorCriblLake$outboundSchema.parse(collectorCriblLake),
+  );
+}
+export function collectorCriblLakeFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorCriblLake, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorCriblLake$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorCriblLake' from JSON`,
+  );
+}

package/src/models/collectordatabase.ts

@@ -0,0 +1,213 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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 { 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;
+};
+
+export type CollectorDatabase = {
+  /**
+   * Collector type: database
+   */
+  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;
+};
+
+/** @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,
+  z.ZodTypeDef,
+  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",
+  });
+});
+/** @internal */
+export type CollectorDatabase$Outbound = {
+  type: "database";
+  connectionId: string;
+  query: string;
+  queryValidationEnabled: boolean;
+  defaultBreakers?: string | undefined;
+  __scheduling?: CollectorDatabaseScheduling$Outbound | undefined;
+};
+
+/** @internal */
+export const CollectorDatabase$outboundSchema: z.ZodType<
+  CollectorDatabase$Outbound,
+  z.ZodTypeDef,
+  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",
+  });
+});
+
+export function collectorDatabaseToJSON(
+  collectorDatabase: CollectorDatabase,
+): string {
+  return JSON.stringify(
+    CollectorDatabase$outboundSchema.parse(collectorDatabase),
+  );
+}
+export function collectorDatabaseFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorDatabase, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorDatabase$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorDatabase' from JSON`,
+  );
+}