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

package/src/models/collectorrest.ts

@@ -0,0 +1,423 @@
+/*
+ * 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";
+
+/**
+ * Defines how task discovery will be performed. Each entry returned by the Discover operation will result in a Collect task.
+ */
+export const CollectorRestDiscoverType = {
+  Http: "http",
+  Json: "json",
+  List: "list",
+  None: "none",
+} as const;
+/**
+ * Defines how task discovery will be performed. Each entry returned by the Discover operation will result in a Collect task.
+ */
+export type CollectorRestDiscoverType = OpenEnum<
+  typeof CollectorRestDiscoverType
+>;
+
+export type CollectorRestDiscovery = {
+  /**
+   * Defines how task discovery will be performed. Each entry returned by the Discover operation will result in a Collect task.
+   */
+  discoverType?: CollectorRestDiscoverType | undefined;
+};
+
+export const CollectMethod = {
+  /**
+   * GET
+   */
+  Get: "get",
+  /**
+   * POST
+   */
+  Post: "post",
+  /**
+   * POST with Body
+   */
+  PostWithBody: "post_with_body",
+  /**
+   * Other
+   */
+  Other: "other",
+} as const;
+export type CollectMethod = OpenEnum<typeof CollectMethod>;
+
+export type CollectorRestCollectRequestHeader = {
+  name: string;
+  /**
+   * JavaScript expression to compute parameter value, usually enclosed in backticks (`${earliest}`). If a constant, use single quotes ('earliest'). Values that aren't successfully evaluated as JavaScript expressions will be treated as string constants.
+   */
+  value: string;
+};
+
+export const PaginationEnum = {
+  /**
+   * None
+   */
+  None: "none",
+  /**
+   * Response Body Attribute
+   */
+  ResponseBody: "response_body",
+  /**
+   * Response Header Attribute
+   */
+  ResponseHeader: "response_header",
+  /**
+   * RFC 5988 - Web Linking
+   */
+  ResponseHeaderLink: "response_header_link",
+  /**
+   * Offset/Limit
+   */
+  RequestOffset: "request_offset",
+  /**
+   * Page/Size
+   */
+  RequestPage: "request_page",
+} as const;
+export type PaginationEnum = OpenEnum<typeof PaginationEnum>;
+
+export type Pagination = {
+  type?: PaginationEnum | undefined;
+};
+
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API key–based authentication by adding the appropriate Collect headers.
+ */
+export const CollectorRestAuthentication = {
+  None: "none",
+  Basic: "basic",
+  BasicSecret: "basicSecret",
+  Login: "login",
+  LoginSecret: "loginSecret",
+  Oauth: "oauth",
+  OauthSecret: "oauthSecret",
+  GoogleOauth: "google_oauth",
+  GoogleOauthSecret: "google_oauthSecret",
+  Hmac: "hmac",
+} as const;
+/**
+ * Authentication method for Discover and Collect REST calls. You can specify API key–based authentication by adding the appropriate Collect headers.
+ */
+export type CollectorRestAuthentication = OpenEnum<
+  typeof CollectorRestAuthentication
+>;
+
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export const CollectorRestRetryType = {
+  /**
+   * Disabled
+   */
+  None: "none",
+  /**
+   * Backoff
+   */
+  Backoff: "backoff",
+  /**
+   * Static
+   */
+  Static: "static",
+} as const;
+/**
+ * Algorithm to use when performing HTTP retries
+ */
+export type CollectorRestRetryType = OpenEnum<typeof CollectorRestRetryType>;
+
+export type CollectorRestRetryRules = {
+  /**
+   * Algorithm to use when performing HTTP retries
+   */
+  type?: CollectorRestRetryType | undefined;
+  interval?: any | undefined;
+  limit?: any | undefined;
+  multiplier?: any | undefined;
+  maxIntervalMs?: any | undefined;
+  codes?: any | undefined;
+  enableHeader?: any | undefined;
+  retryConnectTimeout?: any | undefined;
+  retryConnectReset?: any | undefined;
+};
+
+export type CollectorRestStateTracking = {
+  /**
+   * Track collection progress between consecutive scheduled executions
+   */
+  enabled?: boolean | undefined;
+};
+
+export type CollectorRestScheduling = {
+  stateTracking?: CollectorRestStateTracking | undefined;
+};
+
+export type CollectorRest = {
+  /**
+   * Collector type: rest
+   */
+  type: "rest";
+  discovery?: CollectorRestDiscovery | undefined;
+  /**
+   * URL (constant or JavaScript expression) to use for the Collect operation
+   */
+  collectUrl: string;
+  collectMethod?: CollectMethod | undefined;
+  collectVerb?: any | undefined;
+  collectRequestParams?: any | undefined;
+  collectBody?: any | undefined;
+  collectRequestHeaders?: Array<CollectorRestCollectRequestHeader> | undefined;
+  pagination?: Pagination | undefined;
+  /**
+   * Authentication method for Discover and Collect REST calls. You can specify API key–based authentication by adding the appropriate Collect headers.
+   */
+  authentication?: CollectorRestAuthentication | undefined;
+  /**
+   * HTTP request inactivity timeout. Use 0 to disable.
+   */
+  timeout?: number | undefined;
+  /**
+   * Use round-robin DNS lookup. Suitable when DNS server returns multiple addresses in sort order.
+   */
+  useRoundRobinDns?: boolean | undefined;
+  /**
+   * Disable Collector event time filtering when a date range is specified
+   */
+  disableTimeFilter?: boolean | undefined;
+  /**
+   * Decode the URL before sending requests (including pagination requests)
+   */
+  decodeUrl?: boolean | undefined;
+  /**
+   * Reject certificates that cannot be verified against a valid CA (such as self-signed certificates)
+   */
+  rejectUnauthorized?: boolean | undefined;
+  /**
+   * Enable to add response headers to the resHeaders field under the __collectible object
+   */
+  captureHeaders?: boolean | undefined;
+  /**
+   * Stop pagination when the Event Breaker produces no events
+   */
+  stopOnEmptyResults?: boolean | undefined;
+  /**
+   * List of headers that are safe to log in plain text
+   */
+  safeHeaders?: Array<string> | undefined;
+  retryRules?: CollectorRestRetryRules | undefined;
+  scheduling?: CollectorRestScheduling | undefined;
+};
+
+/** @internal */
+export const CollectorRestDiscoverType$inboundSchema: z.ZodType<
+  CollectorRestDiscoverType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectorRestDiscoverType);
+
+/** @internal */
+export const CollectorRestDiscovery$inboundSchema: z.ZodType<
+  CollectorRestDiscovery,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  discoverType: CollectorRestDiscoverType$inboundSchema.default("none"),
+});
+
+export function collectorRestDiscoveryFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorRestDiscovery, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorRestDiscovery$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorRestDiscovery' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectMethod$inboundSchema: z.ZodType<
+  CollectMethod,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectMethod);
+
+/** @internal */
+export const CollectorRestCollectRequestHeader$inboundSchema: z.ZodType<
+  CollectorRestCollectRequestHeader,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  value: z.string(),
+});
+
+export function collectorRestCollectRequestHeaderFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorRestCollectRequestHeader, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorRestCollectRequestHeader$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorRestCollectRequestHeader' from JSON`,
+  );
+}
+
+/** @internal */
+export const PaginationEnum$inboundSchema: z.ZodType<
+  PaginationEnum,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PaginationEnum);
+
+/** @internal */
+export const Pagination$inboundSchema: z.ZodType<
+  Pagination,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: PaginationEnum$inboundSchema.default("none"),
+});
+
+export function paginationFromJSON(
+  jsonString: string,
+): SafeParseResult<Pagination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Pagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Pagination' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectorRestAuthentication$inboundSchema: z.ZodType<
+  CollectorRestAuthentication,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectorRestAuthentication);
+
+/** @internal */
+export const CollectorRestRetryType$inboundSchema: z.ZodType<
+  CollectorRestRetryType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectorRestRetryType);
+
+/** @internal */
+export const CollectorRestRetryRules$inboundSchema: z.ZodType<
+  CollectorRestRetryRules,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: CollectorRestRetryType$inboundSchema.default("backoff"),
+  interval: z.any().optional(),
+  limit: z.any().optional(),
+  multiplier: z.any().optional(),
+  maxIntervalMs: z.any().optional(),
+  codes: z.any().optional(),
+  enableHeader: z.any().optional(),
+  retryConnectTimeout: z.any().optional(),
+  retryConnectReset: z.any().optional(),
+});
+
+export function collectorRestRetryRulesFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorRestRetryRules, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorRestRetryRules$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorRestRetryRules' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectorRestStateTracking$inboundSchema: z.ZodType<
+  CollectorRestStateTracking,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().optional(),
+});
+
+export function collectorRestStateTrackingFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorRestStateTracking, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorRestStateTracking$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorRestStateTracking' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectorRestScheduling$inboundSchema: z.ZodType<
+  CollectorRestScheduling,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  stateTracking: z.lazy(() => CollectorRestStateTracking$inboundSchema)
+    .optional(),
+});
+
+export function collectorRestSchedulingFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorRestScheduling, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorRestScheduling$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorRestScheduling' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectorRest$inboundSchema: z.ZodType<
+  CollectorRest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("rest"),
+  discovery: z.lazy(() => CollectorRestDiscovery$inboundSchema).optional(),
+  collectUrl: z.string(),
+  collectMethod: CollectMethod$inboundSchema.default("get"),
+  collectVerb: z.any().optional(),
+  collectRequestParams: z.any().optional(),
+  collectBody: z.any().optional(),
+  collectRequestHeaders: z.array(
+    z.lazy(() => CollectorRestCollectRequestHeader$inboundSchema),
+  ).optional(),
+  pagination: z.lazy(() => Pagination$inboundSchema).optional(),
+  authentication: CollectorRestAuthentication$inboundSchema.default("none"),
+  timeout: z.number().default(0),
+  useRoundRobinDns: z.boolean().default(false),
+  disableTimeFilter: z.boolean().default(false),
+  decodeUrl: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(false),
+  captureHeaders: z.boolean().default(false),
+  stopOnEmptyResults: z.boolean().default(false),
+  safeHeaders: z.array(z.string()).optional(),
+  retryRules: z.lazy(() => CollectorRestRetryRules$inboundSchema).optional(),
+  __scheduling: z.lazy(() => CollectorRestScheduling$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "__scheduling": "scheduling",
+  });
+});
+
+export function collectorRestFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorRest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorRest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorRest' from JSON`,
+  );
+}

package/src/models/collectors3.ts

@@ -0,0 +1,248 @@
+/*
+ * 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";
+
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export const PartitioningScheme = {
+  /**
+   * Defined in Path
+   */
+  None: "none",
+  /**
+   * DDSS
+   */
+  Ddss: "ddss",
+} as const;
+/**
+ * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+ */
+export type PartitioningScheme = OpenEnum<typeof PartitioningScheme>;
+
+export type CollectorS3Extractor = {
+  /**
+   * A token from the template path, such as epoch
+   */
+  key: string;
+  /**
+   * JavaScript expression that receives token under "value" variable, and evaluates to populate event fields. Example: {date: new Date(+value*1000)}
+   */
+  expression: string;
+};
+
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export const CollectorS3AuthenticationMethod = {
+  /**
+   * Auto
+   */
+  Auto: "auto",
+  /**
+   * Manual
+   */
+  Manual: "manual",
+  /**
+   * Secret Key pair
+   */
+  Secret: "secret",
+} as const;
+/**
+ * AWS authentication method. Choose Auto to use IAM roles.
+ */
+export type CollectorS3AuthenticationMethod = OpenEnum<
+  typeof CollectorS3AuthenticationMethod
+>;
+
+/**
+ * Signature version to use for signing S3 requests
+ */
+export const CollectorS3SignatureVersion = {
+  V2: "v2",
+  V4: "v4",
+} as const;
+/**
+ * Signature version to use for signing S3 requests
+ */
+export type CollectorS3SignatureVersion = OpenEnum<
+  typeof CollectorS3SignatureVersion
+>;
+
+export type CollectorS3 = {
+  /**
+   * Collector type: s3
+   */
+  type: "s3";
+  /**
+   * Name of the predefined Destination that will be used to auto-populate Collector settings
+   */
+  outputName?: string | undefined;
+  /**
+   * S3 Bucket from which to collect data
+   */
+  bucket: string;
+  /**
+   * Maximum file size for each Parquet chunk
+   */
+  parquetChunkSizeMB?: number | undefined;
+  /**
+   * Maximum time allowed for downloading a Parquet chunk. Processing will stop if a chunk cannot be downloaded within the time specified.
+   */
+  parquetChunkDownloadTimeout?: number | undefined;
+  /**
+   * Region from which to retrieve data
+   */
+  region?: string | undefined;
+  /**
+   * Directory where data will be collected. Templating (such as 'myDir/${datacenter}/${host}/${app}/') and time-based tokens (such as 'myOtherDir/${_time:%Y}/${_time:%m}/${_time:%d}/') are supported. Can be a constant (enclosed in quotes) or a JavaScript expression.
+   */
+  path?: string | undefined;
+  /**
+   * Partitioning scheme used for this dataset. Using a known scheme like DDSS enables more efficient data reading and retrieval.
+   */
+  partitioningScheme?: PartitioningScheme | undefined;
+  /**
+   * 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<CollectorS3Extractor> | undefined;
+  /**
+   * AWS authentication method. Choose Auto to use IAM roles.
+   */
+  awsAuthenticationMethod?: CollectorS3AuthenticationMethod | undefined;
+  /**
+   * Must point to an S3-compatible endpoint. If empty, defaults to an AWS region-specific endpoint.
+   */
+  endpoint?: string | undefined;
+  /**
+   * Signature version to use for signing S3 requests
+   */
+  signatureVersion?: CollectorS3SignatureVersion | undefined;
+  /**
+   * Use AssumeRole credentials
+   */
+  enableAssumeRole?: boolean | undefined;
+  /**
+   * Amazon Resource Name (ARN) of the role to assume
+   */
+  assumeRoleArn?: string | undefined;
+  /**
+   * External ID to use when assuming role
+   */
+  assumeRoleExternalId?: string | undefined;
+  /**
+   * Duration of the Assumed Role's session, in seconds. Minimum is 900 (15 minutes), default is 3600 (1 hour), and maximum is 43200 (12 hours).
+   */
+  durationSeconds?: number | undefined;
+  /**
+   * Maximum number of metadata objects to batch before recording as results
+   */
+  maxBatchSize?: number | undefined;
+  recurse?: any | undefined;
+  /**
+   * Reuse connections between requests to improve performance
+   */
+  reuseConnections?: boolean | undefined;
+  /**
+   * Reject certificates that cannot be verified against a valid CA (such as a self-signed certificate)
+   */
+  rejectUnauthorized?: boolean | undefined;
+  /**
+   * Disable if you can access files within the bucket but not the bucket itself. Resolves errors of the form "discover task initialization failed...error: Forbidden".
+   */
+  verifyPermissions?: boolean | undefined;
+  /**
+   * Disable Collector event time filtering when a date range is specified
+   */
+  disableTimeFilter?: boolean | undefined;
+};
+
+/** @internal */
+export const PartitioningScheme$inboundSchema: z.ZodType<
+  PartitioningScheme,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PartitioningScheme);
+
+/** @internal */
+export const CollectorS3Extractor$inboundSchema: z.ZodType<
+  CollectorS3Extractor,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  expression: z.string(),
+});
+
+export function collectorS3ExtractorFromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorS3Extractor, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorS3Extractor$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorS3Extractor' from JSON`,
+  );
+}
+
+/** @internal */
+export const CollectorS3AuthenticationMethod$inboundSchema: z.ZodType<
+  CollectorS3AuthenticationMethod,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectorS3AuthenticationMethod);
+
+/** @internal */
+export const CollectorS3SignatureVersion$inboundSchema: z.ZodType<
+  CollectorS3SignatureVersion,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectorS3SignatureVersion);
+
+/** @internal */
+export const CollectorS3$inboundSchema: z.ZodType<
+  CollectorS3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("s3"),
+  outputName: z.string().optional(),
+  bucket: z.string(),
+  parquetChunkSizeMB: z.number().default(5),
+  parquetChunkDownloadTimeout: z.number().default(600),
+  region: z.string().optional(),
+  path: z.string().optional(),
+  partitioningScheme: PartitioningScheme$inboundSchema.default("none"),
+  extractors: z.array(z.lazy(() => CollectorS3Extractor$inboundSchema))
+    .optional(),
+  awsAuthenticationMethod: CollectorS3AuthenticationMethod$inboundSchema
+    .default("auto"),
+  endpoint: z.string().optional(),
+  signatureVersion: CollectorS3SignatureVersion$inboundSchema.default("v4"),
+  enableAssumeRole: z.boolean().default(false),
+  assumeRoleArn: z.string().optional(),
+  assumeRoleExternalId: z.string().optional(),
+  durationSeconds: z.number().default(3600),
+  maxBatchSize: z.number().default(10),
+  recurse: z.any().optional(),
+  reuseConnections: z.boolean().default(true),
+  rejectUnauthorized: z.boolean().default(true),
+  verifyPermissions: z.boolean().default(true),
+  disableTimeFilter: z.boolean().default(false),
+});
+
+export function collectorS3FromJSON(
+  jsonString: string,
+): SafeParseResult<CollectorS3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CollectorS3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CollectorS3' from JSON`,
+  );
+}