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

package/src/models/functionlocalsearchrulesetrunner.ts

@@ -5,12 +5,21 @@
 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";
-import {
-  FunctionConfSchemaLocalSearchRulesetRunner,
-  FunctionConfSchemaLocalSearchRulesetRunner$inboundSchema,
-} from "./functionconfschemalocalsearchrulesetrunner.js";
+
+export const RulesetType = {
+  Dataset: "dataset",
+  Datatype: "datatype",
+} as const;
+export type RulesetType = OpenEnum<typeof RulesetType>;
+
+export type FunctionLocalSearchRulesetRunnerSchema = {
+  rulesetType?: RulesetType | undefined;
+  rulesetId?: string | undefined;
+};
 
 export type FunctionLocalSearchRulesetRunner = {
   filename: string;
@@ -26,9 +35,37 @@ export type FunctionLocalSearchRulesetRunner = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaLocalSearchRulesetRunner | undefined;
+  schema?: FunctionLocalSearchRulesetRunnerSchema | undefined;
 };
 
+/** @internal */
+export const RulesetType$inboundSchema: z.ZodType<
+  RulesetType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(RulesetType);
+
+/** @internal */
+export const FunctionLocalSearchRulesetRunnerSchema$inboundSchema: z.ZodType<
+  FunctionLocalSearchRulesetRunnerSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  rulesetType: RulesetType$inboundSchema.optional(),
+  rulesetId: z.string().optional(),
+});
+
+export function functionLocalSearchRulesetRunnerSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionLocalSearchRulesetRunnerSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      FunctionLocalSearchRulesetRunnerSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionLocalSearchRulesetRunnerSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionLocalSearchRulesetRunner$inboundSchema: z.ZodType<
   FunctionLocalSearchRulesetRunner,
@@ -48,7 +85,8 @@ export const FunctionLocalSearchRulesetRunner$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaLocalSearchRulesetRunner$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionLocalSearchRulesetRunnerSchema$inboundSchema)
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionlookup.ts

@@ -7,10 +7,59 @@ 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";
-import {
-  FunctionConfSchemaLookup,
-  FunctionConfSchemaLookup$inboundSchema,
-} from "./functionconfschemalookup.js";
+
+export type InField = {
+  /**
+   * Field name as it appears in events
+   */
+  eventField: string;
+  /**
+   * Optional: The field name as it appears in the lookup file. Defaults to event field name
+   */
+  lookupField?: string | undefined;
+};
+
+export type OutField = {
+  /**
+   * The field name as it appears in the lookup file
+   */
+  lookupField: string;
+  /**
+   * Optional: Field name to add to event. Defaults to lookup field name.
+   */
+  eventField?: string | undefined;
+  /**
+   * Optional: Value to assign if lookup entry is not found
+   */
+  defaultValue?: string | undefined;
+};
+
+export type FunctionLookupSchema = {
+  /**
+   * Path to the lookup file. Reference environment variables via $. Example: $HOME/file.csv
+   */
+  file?: string | undefined;
+  /**
+   * Enable to use a disk-based lookup. This option displays only the settings relevant to disk-based mode and hides those for in-memory lookups.
+   */
+  dbLookup?: boolean | undefined;
+  matchMode?: any | undefined;
+  matchType?: any | undefined;
+  reloadPeriodSec?: any | undefined;
+  /**
+   * Fields that should be used to key into the lookup table
+   */
+  inFields?: Array<InField> | undefined;
+  /**
+   * Fields to add to events after matching lookup. Defaults to all if not specified.
+   */
+  outFields?: Array<OutField> | undefined;
+  /**
+   * Add the looked-up values to _raw, as key=value pairs
+   */
+  addToEvent?: boolean | undefined;
+  ignoreCase?: any | undefined;
+};
 
 export type FunctionLookup = {
   filename: string;
@@ -26,9 +75,74 @@ export type FunctionLookup = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaLookup | undefined;
+  schema?: FunctionLookupSchema | undefined;
 };
 
+/** @internal */
+export const InField$inboundSchema: z.ZodType<InField, z.ZodTypeDef, unknown> =
+  z.object({
+    eventField: z.string(),
+    lookupField: z.string().optional(),
+  });
+
+export function inFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<InField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InField' from JSON`,
+  );
+}
+
+/** @internal */
+export const OutField$inboundSchema: z.ZodType<
+  OutField,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  lookupField: z.string(),
+  eventField: z.string().optional(),
+  defaultValue: z.string().optional(),
+});
+
+export function outFieldFromJSON(
+  jsonString: string,
+): SafeParseResult<OutField, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OutField$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutField' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionLookupSchema$inboundSchema: z.ZodType<
+  FunctionLookupSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  file: z.string().optional(),
+  dbLookup: z.boolean().default(false),
+  matchMode: z.any().optional(),
+  matchType: z.any().optional(),
+  reloadPeriodSec: z.any().optional(),
+  inFields: z.array(z.lazy(() => InField$inboundSchema)).optional(),
+  outFields: z.array(z.lazy(() => OutField$inboundSchema)).optional(),
+  addToEvent: z.boolean().default(false),
+  ignoreCase: z.any().optional(),
+});
+
+export function functionLookupSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionLookupSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionLookupSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionLookupSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionLookup$inboundSchema: z.ZodType<
   FunctionLookup,
@@ -48,7 +162,7 @@ export const FunctionLookup$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaLookup$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionLookupSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionmask.ts

@@ -7,10 +7,45 @@ 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";
-import {
-  FunctionConfSchemaMask,
-  FunctionConfSchemaMask$inboundSchema,
-} from "./functionconfschemamask.js";
+
+export type FunctionMaskRule = {
+  /**
+   * Pattern to replace. Use /g to replace all matches.
+   */
+  matchRegex: string;
+  /**
+   * A JavaScript expression or literal to replace the matching content. Capturing groups can be referenced as g1, g2, and so on, and event fields as event.<fieldName>.
+   */
+  replaceExpr?: string | undefined;
+  /**
+   * Set to No to disable the evaluation of an individual rule
+   */
+  disabled?: boolean | undefined;
+};
+
+export type FunctionMaskFlag = {
+  name?: string | undefined;
+  /**
+   * JavaScript expression to compute the value (can be constant)
+   */
+  value: string;
+};
+
+export type FunctionMaskSchema = {
+  rules?: Array<FunctionMaskRule> | undefined;
+  /**
+   * Fields on which to apply the masking rules. Supports * wildcards, except when used on internal fields.
+   */
+  fields?: Array<string> | undefined;
+  /**
+   * Depth to which the Mask Function will search for fields to mask
+   */
+  depth?: number | undefined;
+  /**
+   * Fields to evaluate if one or more masking rules are matched
+   */
+  flags?: Array<FunctionMaskFlag> | undefined;
+};
 
 export type FunctionMask = {
   filename: string;
@@ -26,9 +61,72 @@ export type FunctionMask = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaMask | undefined;
+  schema?: FunctionMaskSchema | undefined;
 };
 
+/** @internal */
+export const FunctionMaskRule$inboundSchema: z.ZodType<
+  FunctionMaskRule,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  matchRegex: z.string(),
+  replaceExpr: z.string().default("''"),
+  disabled: z.boolean().default(false),
+});
+
+export function functionMaskRuleFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionMaskRule, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionMaskRule$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionMaskRule' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionMaskFlag$inboundSchema: z.ZodType<
+  FunctionMaskFlag,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  value: z.string(),
+});
+
+export function functionMaskFlagFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionMaskFlag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionMaskFlag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionMaskFlag' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionMaskSchema$inboundSchema: z.ZodType<
+  FunctionMaskSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  rules: z.array(z.lazy(() => FunctionMaskRule$inboundSchema)).optional(),
+  fields: z.array(z.string()).optional(),
+  depth: z.number().int().default(5),
+  flags: z.array(z.lazy(() => FunctionMaskFlag$inboundSchema)).optional(),
+});
+
+export function functionMaskSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionMaskSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionMaskSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionMaskSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionMask$inboundSchema: z.ZodType<
   FunctionMask,
@@ -48,7 +146,7 @@ export const FunctionMask$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaMask$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionMaskSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionmvexpand.ts

@@ -5,12 +5,51 @@
 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";
-import {
-  FunctionConfSchemaMvExpand,
-  FunctionConfSchemaMvExpand$inboundSchema,
-} from "./functionconfschemamvexpand.js";
+
+/**
+ * decides if bag-values are expanded to bags or arrays
+ */
+export const BagExpansionMode = {
+  /**
+   * Store as object
+   */
+  Bag: "bag",
+  /**
+   * Store as array
+   */
+  Array: "array",
+} as const;
+/**
+ * decides if bag-values are expanded to bags or arrays
+ */
+export type BagExpansionMode = OpenEnum<typeof BagExpansionMode>;
+
+export type FunctionMvExpandSchema = {
+  /**
+   * Array of property-/field-names to expand
+   */
+  sourceFields?: Array<string> | undefined;
+  /**
+   * stores the value as new target field name
+   */
+  targetNames?: Array<string> | undefined;
+  /**
+   * max. number of rows generated out of every source events
+   */
+  rowLimit?: number | undefined;
+  /**
+   * name of an optional index property generated into the output
+   */
+  itemIndexName?: string | undefined;
+  /**
+   * decides if bag-values are expanded to bags or arrays
+   */
+  bagExpansionMode?: BagExpansionMode | undefined;
+};
 
 export type FunctionMvExpand = {
   filename: string;
@@ -26,9 +65,39 @@ export type FunctionMvExpand = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaMvExpand | undefined;
+  schema?: FunctionMvExpandSchema | undefined;
 };
 
+/** @internal */
+export const BagExpansionMode$inboundSchema: z.ZodType<
+  BagExpansionMode,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(BagExpansionMode);
+
+/** @internal */
+export const FunctionMvExpandSchema$inboundSchema: z.ZodType<
+  FunctionMvExpandSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  sourceFields: z.array(z.string()).optional(),
+  targetNames: z.array(z.string()).optional(),
+  rowLimit: z.number().default(9007199254740991),
+  itemIndexName: z.string().optional(),
+  bagExpansionMode: BagExpansionMode$inboundSchema.default("bag"),
+});
+
+export function functionMvExpandSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionMvExpandSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionMvExpandSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionMvExpandSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionMvExpand$inboundSchema: z.ZodType<
   FunctionMvExpand,
@@ -48,7 +117,7 @@ export const FunctionMvExpand$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaMvExpand$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionMvExpandSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",

package/src/models/functionmvpull.ts

@@ -7,10 +7,29 @@ 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";
-import {
-  FunctionConfSchemaMvPull,
-  FunctionConfSchemaMvPull$inboundSchema,
-} from "./functionconfschemamvpull.js";
+
+export type FunctionMvPullSchema = {
+  /**
+   * Field name of the array within events that contains the data objects of interest. Can be a path.
+   */
+  arrayPath?: string | undefined;
+  /**
+   * Extract the K-V pair's key from this field, relative to the data object.
+   */
+  relativeKeyPath?: string | undefined;
+  /**
+   * Extract the K-V pair's value from this field, relative to the data object.
+   */
+  relativeValuePath?: string | undefined;
+  /**
+   * Optionally, specify a bag as the target for K-V entries. If not specified, these entries are stored on each top-level event.
+   */
+  targetBagPath?: string | null | undefined;
+  /**
+   * Toggle this on to remove each original array of data objects after extraction. If toggled off, arrays are retained.
+   */
+  deleteOriginal?: boolean | undefined;
+};
 
 export type FunctionMvPull = {
   filename: string;
@@ -26,9 +45,32 @@ export type FunctionMvPull = {
   sync?: boolean | undefined;
   uischema: { [k: string]: any };
   version: string;
-  schema?: FunctionConfSchemaMvPull | undefined;
+  schema?: FunctionMvPullSchema | undefined;
 };
 
+/** @internal */
+export const FunctionMvPullSchema$inboundSchema: z.ZodType<
+  FunctionMvPullSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  arrayPath: z.string().optional(),
+  relativeKeyPath: z.string().optional(),
+  relativeValuePath: z.string().optional(),
+  targetBagPath: z.nullable(z.string()).default(null),
+  deleteOriginal: z.boolean().default(false),
+});
+
+export function functionMvPullSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionMvPullSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionMvPullSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionMvPullSchema' from JSON`,
+  );
+}
+
 /** @internal */
 export const FunctionMvPull$inboundSchema: z.ZodType<
   FunctionMvPull,
@@ -48,7 +90,7 @@ export const FunctionMvPull$inboundSchema: z.ZodType<
   sync: z.boolean().optional(),
   uischema: z.record(z.any()),
   version: z.string(),
-  schema: FunctionConfSchemaMvPull$inboundSchema.optional(),
+  schema: z.lazy(() => FunctionMvPullSchema$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "__filename": "filename",