cribl-control-plane 0.5.0-beta.1 → 0.5.0-beta.2

package/src/models/functionaggregation.ts

@@ -7,77 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-
-export type FunctionAggregationAdd = {
-  name?: string | undefined;
-  /**
-   * JavaScript expression to compute the value (can be constant)
-   */
-  value: string;
-};
-
-export type FunctionAggregationSchema = {
-  /**
-   * Pass through the original events along with the aggregation events
-   */
-  passthrough?: boolean | undefined;
-  /**
-   * Preserve the structure of the original aggregation event's groupby fields
-   */
-  preserveGroupBys?: boolean | undefined;
-  /**
-   * Output only statistics that are sufficient for the supplied aggregations
-   */
-  sufficientStatsOnly?: boolean | undefined;
-  /**
-   * Enable to output the aggregates as metrics. When disabled, aggregates are output as events.
-   */
-  metricsMode?: boolean | undefined;
-  /**
-   * A prefix that is prepended to all of the fields output by this Aggregations Function
-   */
-  prefix?: string | undefined;
-  /**
-   * The time span of the tumbling window for aggregating events. Must be a valid time string (such as 10s).
-   */
-  timeWindow?: string | undefined;
-  /**
-   * Aggregate function to perform on events. Example: sum(bytes).where(action=='REJECT').as(TotalBytes)
-   */
-  aggregations?: Array<string> | undefined;
-  /**
-   * Optional: One or more fields to group aggregates by. Supports wildcard expressions. Warning: Using wildcard '*' causes all fields in the event to be included, which can result in high cardinality and increased memory usage. Exclude fields that can result in high cardinality before using wildcards. Example: !_time, !_numericValue, *
-   */
-  groupbys?: Array<string> | undefined;
-  /**
-   * The maximum number of events to include in any given aggregation event
-   */
-  flushEventLimit?: number | undefined;
-  /**
-   * The memory usage limit to impose upon aggregations. Defaults to 80% of the process memory; value configured above default limit is ignored. Accepts numerals with units like KB and MB (example: 128MB).
-   */
-  flushMemLimit?: string | undefined;
-  /**
-   * Enable to retain aggregations for cumulative aggregations when flushing out an aggregation table event. When disabled (the default), aggregations are reset to 0 on flush.
-   */
-  cumulative?: boolean | undefined;
-  /**
-   * Allows Cribl Search-specific aggregation configuration
-   */
-  searchAggMode?: string | undefined;
-  /**
-   * Set of key-value pairs to evaluate and add/set
-   */
-  add?: Array<FunctionAggregationAdd> | undefined;
-  /**
-   * Treat dots in dimension names as literals. This is useful for top-level dimensions that contain dots, such as 'service.name'.
-   */
-  shouldTreatDotsAsLiterals?: boolean | undefined;
-  /**
-   * Flush aggregations when an input stream is closed. If disabled, Time Window Settings control flush behavior.
-   */
-  flushOnInputClose?: boolean | undefined;
-};
+import {
+  FunctionConfSchemaAggregation,
+  FunctionConfSchemaAggregation$inboundSchema,
+} from "./functionconfschemaaggregation.js";
 
 export type FunctionAggregation = {
   filename: string;
@@ -93,62 +26,9 @@ export type FunctionAggregation = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionAggregationSchema | undefined;
+  schema?: FunctionConfSchemaAggregation | undefined;
 };
 
-/** @internal */
-export const FunctionAggregationAdd$inboundSchema: z.ZodType<
-  FunctionAggregationAdd,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  name: z.string().optional(),
-  value: z.string(),
-});
-
-export function functionAggregationAddFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionAggregationAdd, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionAggregationAdd$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionAggregationAdd' from JSON`,
-  );
-}
-
-/** @internal */
-export const FunctionAggregationSchema$inboundSchema: z.ZodType<
-  FunctionAggregationSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  passthrough: z.boolean().default(false),
-  preserveGroupBys: z.boolean().default(false),
-  sufficientStatsOnly: z.boolean().default(false),
-  metricsMode: z.boolean().default(false),
-  prefix: z.string().optional(),
-  timeWindow: z.string().default("10s"),
-  aggregations: z.array(z.string()).optional(),
-  groupbys: z.array(z.string()).optional(),
-  flushEventLimit: z.number().optional(),
-  flushMemLimit: z.string().optional(),
-  cumulative: z.boolean().default(false),
-  searchAggMode: z.string().optional(),
-  add: z.array(z.lazy(() => FunctionAggregationAdd$inboundSchema)).optional(),
-  shouldTreatDotsAsLiterals: z.boolean().default(false),
-  flushOnInputClose: z.boolean().default(true),
-});
-
-export function functionAggregationSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionAggregationSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionAggregationSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionAggregationSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionAggregation$inboundSchema: z.ZodType<
   FunctionAggregation,
@@ -168,7 +48,7 @@ export const FunctionAggregation$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionAggregationSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaAggregation$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionautotimestamp.ts

@@ -5,87 +5,12 @@
 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";
-
-/**
- * How to set the time field if no timestamp is found
- */
-export const DefaultTime = {
-  /**
-   * Current Time
-   */
-  Now: "now",
-  /**
-   * Last Event's Time
-   */
-  Last: "last",
-  /**
-   * None
-   */
-  None: "none",
-} as const;
-/**
- * How to set the time field if no timestamp is found
- */
-export type DefaultTime = OpenEnum<typeof DefaultTime>;
-
-export type Timestamp = {
-  /**
-   * Regex with first capturing group matching the timestamp
-   */
-  regex: string;
-  /**
-   * Select or enter strptime format for the captured timestamp
-   */
-  strptime: string;
-};
-
-export type FunctionAutoTimestampSchema = {
-  /**
-   * Field to search for a timestamp
-   */
-  srcField?: string | undefined;
-  /**
-   * Field to place timestamp in
-   */
-  dstField?: string | undefined;
-  /**
-   * Timezone to assign to timestamps without timezone info
-   */
-  defaultTimezone?: string | undefined;
-  /**
-   * Expression to use to format time. Current time, as a JavaScript Date object, is in global `time`. You can access other fields' values via __e.<fieldName>.
-   */
-  timeExpression?: string | undefined;
-  /**
-   * The offset into the string from which to look for a timestamp
-   */
-  offset?: number | undefined;
-  /**
-   * Maximum string length at which to look for a timestamp
-   */
-  maxLen?: number | undefined;
-  /**
-   * How to set the time field if no timestamp is found
-   */
-  defaultTime?: DefaultTime | undefined;
-  /**
-   * The latest timestamp value allowed relative to now, such as +42days. Parsed values after this date will be set to the Default time.
-   */
-  latestDateAllowed?: string | undefined;
-  spacer?: string | undefined;
-  /**
-   * The earliest timestamp value allowed relative to now, such as -42years. Parsed values prior to this date will be set to the Default time.
-   */
-  earliestDateAllowed?: string | undefined;
-  /**
-   * Add regex/strptime pairs to extract additional timestamp formats
-   */
-  timestamps?: Array<Timestamp> | undefined;
-};
+import {
+  FunctionConfSchemaAutoTimestamp,
+  FunctionConfSchemaAutoTimestamp$inboundSchema,
+} from "./functionconfschemaautotimestamp.js";
 
 export type FunctionAutoTimestamp = {
   filename: string;
@@ -101,65 +26,9 @@ export type FunctionAutoTimestamp = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionAutoTimestampSchema | undefined;
+  schema?: FunctionConfSchemaAutoTimestamp | undefined;
 };
 
-/** @internal */
-export const DefaultTime$inboundSchema: z.ZodType<
-  DefaultTime,
-  z.ZodTypeDef,
-  unknown
-> = openEnums.inboundSchema(DefaultTime);
-
-/** @internal */
-export const Timestamp$inboundSchema: z.ZodType<
-  Timestamp,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  regex: z.string(),
-  strptime: z.string(),
-});
-
-export function timestampFromJSON(
-  jsonString: string,
-): SafeParseResult<Timestamp, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Timestamp$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Timestamp' from JSON`,
-  );
-}
-
-/** @internal */
-export const FunctionAutoTimestampSchema$inboundSchema: z.ZodType<
-  FunctionAutoTimestampSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  srcField: z.string().default("_raw"),
-  dstField: z.string().default("_time"),
-  defaultTimezone: z.string().default("local"),
-  timeExpression: z.string().default("time.getTime() / 1000"),
-  offset: z.number().default(0),
-  maxLen: z.number().default(150),
-  defaultTime: DefaultTime$inboundSchema.default("now"),
-  latestDateAllowed: z.string().default("+1week"),
-  spacer: z.string().optional(),
-  earliestDateAllowed: z.string().default("-420weeks"),
-  timestamps: z.array(z.lazy(() => Timestamp$inboundSchema)).optional(),
-});
-
-export function functionAutoTimestampSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionAutoTimestampSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionAutoTimestampSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionAutoTimestampSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionAutoTimestamp$inboundSchema: z.ZodType<
   FunctionAutoTimestamp,
@@ -179,7 +48,7 @@ export const FunctionAutoTimestamp$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionAutoTimestampSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaAutoTimestamp$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functioncef.ts

@@ -7,37 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-
-export type Header = {
-  name?: string | undefined;
-  /**
-   * JavaScript expression to compute the value (can be constant)
-   */
-  value: string;
-};
-
-export type Extension = {
-  name: string;
-  /**
-   * JavaScript expression to compute the value (can be constant)
-   */
-  value: string;
-};
-
-export type FunctionCefSchema = {
-  /**
-   * The field to which the CEF formatted event will be output
-   */
-  outputField?: string | undefined;
-  /**
-   * Set of header key/value pairs
-   */
-  header?: Array<Header> | undefined;
-  /**
-   * Set of extension key-value pairs
-   */
-  extension?: Array<Extension> | undefined;
-};
+import {
+  FunctionConfSchemaCef,
+  FunctionConfSchemaCef$inboundSchema,
+} from "./functionconfschemacef.js";
 
 export type FunctionCef = {
   filename: string;
@@ -53,67 +26,9 @@ export type FunctionCef = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionCefSchema | undefined;
+  schema?: FunctionConfSchemaCef | undefined;
 };
 
-/** @internal */
-export const Header$inboundSchema: z.ZodType<Header, z.ZodTypeDef, unknown> = z
-  .object({
-    name: z.string().optional(),
-    value: z.string(),
-  });
-
-export function headerFromJSON(
-  jsonString: string,
-): SafeParseResult<Header, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Header$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Header' from JSON`,
-  );
-}
-
-/** @internal */
-export const Extension$inboundSchema: z.ZodType<
-  Extension,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  name: z.string(),
-  value: z.string(),
-});
-
-export function extensionFromJSON(
-  jsonString: string,
-): SafeParseResult<Extension, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Extension$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Extension' from JSON`,
-  );
-}
-
-/** @internal */
-export const FunctionCefSchema$inboundSchema: z.ZodType<
-  FunctionCefSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  outputField: z.string().default("_raw"),
-  header: z.array(z.lazy(() => Header$inboundSchema)).optional(),
-  extension: z.array(z.lazy(() => Extension$inboundSchema)).optional(),
-});
-
-export function functionCefSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionCefSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionCefSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionCefSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionCef$inboundSchema: z.ZodType<
   FunctionCef,
@@ -133,7 +48,7 @@ export const FunctionCef$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionCefSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaCef$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionchain.ts

@@ -7,13 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-
-export type FunctionChainSchema = {
-  /**
-   * The data processor (Pack/Pipeline) to send events through
-   */
-  processor?: string | undefined;
-};
+import {
+  FunctionConfSchemaChain,
+  FunctionConfSchemaChain$inboundSchema,
+} from "./functionconfschemachain.js";
 
 export type FunctionChain = {
   filename: string;
@@ -29,28 +26,9 @@ export type FunctionChain = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionChainSchema | undefined;
+  schema?: FunctionConfSchemaChain | undefined;
 };
 
-/** @internal */
-export const FunctionChainSchema$inboundSchema: z.ZodType<
-  FunctionChainSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  processor: z.string().optional(),
-});
-
-export function functionChainSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionChainSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionChainSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionChainSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionChain$inboundSchema: z.ZodType<
   FunctionChain,
@@ -70,7 +48,7 @@ export const FunctionChain$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionChainSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaChain$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionclone.ts

@@ -7,13 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-
-export type FunctionCloneSchema = {
-  /**
-   * Create clones with the following fields set
-   */
-  clones?: Array<{ [k: string]: string }> | undefined;
-};
+import {
+  FunctionConfSchemaClone,
+  FunctionConfSchemaClone$inboundSchema,
+} from "./functionconfschemaclone.js";
 
 export type FunctionClone = {
   filename: string;
@@ -29,28 +26,9 @@ export type FunctionClone = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionCloneSchema | undefined;
+  schema?: FunctionConfSchemaClone | undefined;
 };
 
-/** @internal */
-export const FunctionCloneSchema$inboundSchema: z.ZodType<
-  FunctionCloneSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  clones: z.array(z.record(z.string())).optional(),
-});
-
-export function functionCloneSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionCloneSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionCloneSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionCloneSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionClone$inboundSchema: z.ZodType<
   FunctionClone,
@@ -70,7 +48,7 @@ export const FunctionClone$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionCloneSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaClone$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functioncode.ts

@@ -7,25 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-
-export type FunctionCodeSchema = {
-  /**
-   * Caution: This Function will be evaluated in an unprotected context. This means that you will be able to execute almost any JavaScript code.
-   */
-  code?: string | undefined;
-  /**
-   * The maximum number of allowed iterations within this Function. Defaults to 5,000.
-   */
-  maxNumOfIterations?: number | undefined;
-  /**
-   * Rate at which this Function logs errors. For example, a value of 1 (the default) logs every error, a value of 10 logs every tenth error, and so on.
-   */
-  activeLogSampleRate?: number | undefined;
-  /**
-   * Logs from this Function will be sent to a unique channel in the form `func:code:${pipelineName}:${functionIndex}`. Disable to use the generic `func:code` log channel instead.
-   */
-  useUniqueLogChannel?: boolean | undefined;
-};
+import {
+  FunctionConfSchemaCode,
+  FunctionConfSchemaCode$inboundSchema,
+} from "./functionconfschemacode.js";
 
 export type FunctionCode = {
   filename: string;
@@ -41,31 +26,9 @@ export type FunctionCode = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionCodeSchema | undefined;
+  schema?: FunctionConfSchemaCode | undefined;
 };
 
-/** @internal */
-export const FunctionCodeSchema$inboundSchema: z.ZodType<
-  FunctionCodeSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  code: z.string().optional(),
-  maxNumOfIterations: z.number().default(5000),
-  activeLogSampleRate: z.number().default(1),
-  useUniqueLogChannel: z.boolean().default(true),
-});
-
-export function functionCodeSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionCodeSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionCodeSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionCodeSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionCode$inboundSchema: z.ZodType<
   FunctionCode,
@@ -85,7 +48,7 @@ export const FunctionCode$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionCodeSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaCode$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functioncomment.ts

@@ -7,13 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-
-export type FunctionCommentSchema = {
-  /**
-   * Optional, short description of this Function's purpose in the Pipeline
-   */
-  comment?: string | undefined;
-};
+import {
+  FunctionConfSchemaComment,
+  FunctionConfSchemaComment$inboundSchema,
+} from "./functionconfschemacomment.js";
 
 export type FunctionComment = {
   filename: string;
@@ -29,28 +26,9 @@ export type FunctionComment = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionCommentSchema | undefined;
+  schema?: FunctionConfSchemaComment | undefined;
 };
 
-/** @internal */
-export const FunctionCommentSchema$inboundSchema: z.ZodType<
-  FunctionCommentSchema,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  comment: z.string().optional(),
-});
-
-export function functionCommentSchemaFromJSON(
-  jsonString: string,
-): SafeParseResult<FunctionCommentSchema, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FunctionCommentSchema$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FunctionCommentSchema' from JSON`,
-  );
-}
-
 /** @internal */
 export const FunctionComment$inboundSchema: z.ZodType<
   FunctionComment,
@@ -70,7 +48,7 @@ export const FunctionComment$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: z.lazy(() => FunctionCommentSchema$inboundSchema).optional(),
+  schema: FunctionConfSchemaComment$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",