@flow-scanner/lightning-flow-scanner-core 6.16.2 → 6.17.1

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@flow-scanner/lightning-flow-scanner-core",
   "description": "A lightweight engine for Flow metadata in Node.js, and browser environments. Assess and enhance Salesforce Flow automations for best practices, security, governor limits, and performance issues.",
-  "version": "6.16.2",
-  "main": "index.js",
+  "version": "6.17.1",
+  "main": "out/index.js",
   "exports": {
     ".": {
-      "import": "./index.js",
-      "require": "./index.js",
-      "types": "./index.d.ts"
+      "types": "./out/index.d.ts",
+      "import": "./out/index.js",
+      "require": "./out/index.js",
+      "default": "./out/index.js"
     }
   },
   "engines": {
@@ -20,7 +21,35 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "fast-xml-parser": "^5.3.0"
+    "fast-xml-parser": "^5.3.0",
+    "@flow-scanner/regex-scanner": "1.0.0"
+  },
+  "devDependencies": {
+    "@jest/types": "30.0.1",
+    "@swc-node/jest": "1.9.1",
+    "@swc/cli": "0.7.7",
+    "@swc/core": "1.13.5",
+    "@swc/helpers": "0.5.17",
+    "@types/jest": "29.5.14",
+    "@types/node": "22.15.30",
+    "@types/semantic-release": "20.0.6",
+    "cross-env": "^10.1.0",
+    "eslint": "9.30.0",
+    "eslint-plugin-de-morgan": "1.3.0",
+    "eslint-plugin-github": "6.0.0",
+    "eslint-plugin-jest": "29.0.1",
+    "eslint-plugin-perfectionist": "4.15.0",
+    "eslint-plugin-sonarjs": "3.0.4",
+    "husky": "9.1.7",
+    "jest": "30.0.3",
+    "lint-staged": "^16.1.2",
+    "prettier": "3.6.2",
+    "rimraf": "^6.1.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.8.3",
+    "typescript-eslint": "8.35.0",
+    "vite": "6.4.1",
+    "vite-plugin-node-polyfills": "0.23.0"
   },
   "homepage": "https://flow-scanner.github.io/lightning-flow-scanner/",
   "author": {
@@ -39,5 +68,26 @@
     "security-scanner",
     "static-analysis"
   ],
-  "types": "index.d.ts"
-}
+  "scripts": {
+    "clean": "rimraf out dist",
+    "build:js": "swc src --out-dir out --copy-files --strip-leading-paths --config-file .swcrc",
+    "build:types": "tsc -p tsconfig.types.json --declaration --emitDeclarationOnly --outDir out",
+    "prepare:publish": "node ../../.github/scripts/prepare-publish.js",
+    "copy:root-files:dist": "node -e \"['../../LICENSE.md'].forEach(f => { const n = f.split('/').pop(); if (require('fs').existsSync(f)) require('fs').copyFileSync(f, 'dist/'+n) })\"",
+    "____main____": "__DEVELOPER COMMANDS__",
+    "build": "npm run clean && npm run build:js && npm run build:types",
+    "test": "npm run test:umd",
+    "test:node": "jest",
+    "test:umd": "npm run build:js && vite build && npm run copy:root-files:dist && cross-env UMD_PATH=dist/lightning-flow-scanner-core.umd.js jest",
+    "link": "npm run build && npm link ./out",
+    "____pack____": "PACKAGING COMMANDS__",
+    "swc:sim:pack": "npm run build",
+    "vite:dist": "npm run build:js && vite build && npm run copy:root-files:dist",
+    "stryker": "npm i -g @stryker-mutator/core @stryker-mutator/jest-runner && stryker run",
+    "version:patch": "pnpm version patch --no-git-tag-version",
+    "version:minor": "pnpm version minor --no-git-tag-version",
+    "version:major": "pnpm version major --no-git-tag-version",
+    "publish:npm": "npm run build && npm run prepare:publish && cd out && npm publish",
+    "tag": "node ../../scripts/publish-core-tag.js"
+  }
+}

package/prettier.config.mjs

@@ -0,0 +1,5 @@
+export default {
+  printWidth: 100,
+  tabWidth: 2,
+  trailingComma: "es5",
+};

package/src/index.ts

@@ -0,0 +1,52 @@
+// Updated exports in index.ts
+import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
+import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
+import type { FlatViolation } from "./main/models/FlatViolation";
+import { Compiler } from "./main/libs/Compiler";
+import { exportDetails } from "./main/libs/ExportDetails";
+import { exportSarif } from "./main/libs/ExportSarif";
+import { fix } from "./main/libs/FixFlows";
+import { getRules } from "./main/libs/GetRuleDefinitions";
+import { parse } from "./main/libs/ParseFlows";
+import { scan } from "./main/libs/ScanFlows";
+import { Flow } from "./main/models/Flow";
+import { FlowAttribute } from "./main/models/FlowAttribute";
+import { FlowElement } from "./main/models/FlowElement";
+import { FlowNode } from "./main/models/FlowNode";
+import { FlowResource } from "./main/models/FlowResource";
+import { FlowType } from "./main/models/FlowType";
+import { FlowVariable } from "./main/models/FlowVariable";
+import { ParsedFlow } from "./main/models/ParsedFlow";
+import { RuleResult } from "./main/models/RuleResult";
+import { ScanResult } from "./main/models/ScanResult";
+import { Violation } from "./main/models/Violation";
+import { DEFAULT_ICONS, ASCII_ICONS, type NodeIconConfig } from "./main/config/NodeIcons";
+import { DEFAULT_VARIABLE_ICONS, ASCII_VARIABLE_ICONS, type VariableIconConfig } from "./main/config/VariableIcons";
+import { exportDiagram, type DiagramOptions } from "./main/libs/ExportDiagram";
+
+export {
+  Compiler,
+  exportDetails,
+  exportDiagram,
+  exportSarif,
+  fix,
+  Flow,
+  FlowAttribute,
+  FlowElement,
+  FlowNode,
+  FlowResource,
+  FlowType,
+  FlowVariable,
+  getRules,
+  parse,
+  ParsedFlow,
+  Violation,
+  RuleResult,
+  scan,
+  ScanResult,
+  DEFAULT_ICONS,
+  ASCII_ICONS,
+  DEFAULT_VARIABLE_ICONS,
+  ASCII_VARIABLE_ICONS,
+};
+export type { FlatViolation, IRuleDefinition, IRulesConfig, NodeIconConfig, DiagramOptions, VariableIconConfig };

package/src/main/config/NodeIcons.ts

@@ -0,0 +1,98 @@
+/**
+ * Icon configuration for flow node types.
+ * Emoji are safe in UTF-8 encoded source files and will work in all modern builds.
+ * If you need ASCII fallback, use FlowNode.setIconConfig(ASCII_ICONS)
+ */
+
+export interface NodeIconConfig {
+  [nodeType: string]: {
+    [subtype: string]: string;
+  } | { default: string };
+}
+
+/**
+ * Default icons using emoji (recommended for modern environments)
+ */
+export const DEFAULT_ICONS: NodeIconConfig = {
+  actionCalls: {
+    apex: '\u2699\uFE0F',           // GEAR (with emoji presentation)
+    emailAlert: '\uD83D\uDCE7',     // E-MAIL
+    emailSimple: '\uD83D\uDCE7',    // E-MAIL
+    submit: '\u26A1',               // HIGH VOLTAGE
+    default: '\u26A1'               // HIGH VOLTAGE
+  },
+  assignments: { 
+    default: '\uD83D\uDFF0'         // 🟰 HEAVY EQUALS SIGN
+  },
+  collectionProcessors: {
+    FilterCollectionProcessor: '\uD83D\uDD3D',  // DOWN BUTTON
+    SortCollectionProcessor: '\uD83D\uDD03',    // CLOCKWISE ARROWS
+    default: '\uD83D\uDCE6'         // PACKAGE
+  },
+  customErrors: { 
+    default: '\uD83D\uDEAB'         // PROHIBITED
+  },
+  decisions: { 
+    default: '\uD83D\uDD00'         // TWISTED ARROWS
+  },
+  loops: { 
+    default: '\uD83D\uDD01'         // REPEAT BUTTON
+  },
+  recordCreates: { 
+    default: '\u2795'               // PLUS
+  },
+  recordDeletes: { 
+    default: '\uD83D\uDDD1\uFE0F'   // WASTEBASKET
+  },
+  recordLookups: { 
+    default: '\uD83D\uDD0D'         // MAGNIFYING GLASS
+  },
+  recordUpdates: { 
+    default: '\uD83D\uDEE0\uFE0F'   // HAMMER AND WRENCH
+  },
+  screens: { 
+    default: '\uD83D\uDCBB'         // LAPTOP
+  },
+  subflows: { 
+    default: '\uD83D\uDD17'         // LINK
+  },
+  transforms: { 
+    default: '\u267B\uFE0F'
+  },
+};
+
+/**
+ * ASCII fallback icons (for environments without emoji support)
+ */
+export const ASCII_ICONS: NodeIconConfig = {
+  actionCalls: {
+    apex: '[A]',
+    emailAlert: '[E]',
+    emailSimple: '[E]',
+    submit: '[!]',
+    default: '[!]'
+  },
+  assignments: { default: '[=]' },
+  collectionProcessors: {
+    FilterCollectionProcessor: '[F]',
+    SortCollectionProcessor: '[S]',
+    default: '[C]'
+  },
+  customErrors: { default: '[X]' },
+  decisions: { default: '[?]' },
+  loops: { default: '[L]' },
+  recordCreates: { default: '[+]' },
+  recordDeletes: { default: '[-]' },
+  recordLookups: { default: '[S]' },
+  recordUpdates: { default: '[U]' },
+  screens: { default: '[#]' },
+  subflows: { default: '[>]' },
+  transforms: { default: '[T]' },
+};
+
+/**
+ * Get default icon config (can be overridden at runtime)
+ */
+export function getDefaultIconConfig(): NodeIconConfig {
+  return DEFAULT_ICONS;
+}

package/src/main/config/RegexAdapter.ts

@@ -0,0 +1,98 @@
+/**
+ * Adapter functions to convert between core models (Flow, Violation)
+ * and regex-scanner models (MetadataFile, RegexViolation).
+ *
+ * This allows core rules to delegate to regex-scanner while maintaining
+ * backward compatibility with existing consumers.
+ */
+
+import type {
+  MetadataFile,
+  MetadataElement,
+  RegexViolation,
+} from "@flow-scanner/regex-scanner";
+
+import { Flow } from "../models/Flow";
+import { FlowAttribute } from "../models/FlowAttribute";
+import { FlowElement } from "../models/FlowElement";
+import { Violation } from "../models/Violation";
+import { MetaType } from "../enums/MetadataTypes";
+
+/**
+ * Convert a Flow object to a MetadataFile for regex-scanner.
+ */
+export function toMetadataFile(flow: Flow): MetadataFile {
+  // Handle case where toXMLString may not exist (e.g., in tests with partial Flow objects)
+  let content = "";
+  if (typeof flow.toXMLString === "function") {
+    content = flow.toXMLString();
+  }
+
+  return {
+    name: flow.name,
+    fileName: flow.uri
+      ? flow.uri.split(/[\\/]/).pop() ?? `${flow.name}.flow-meta.xml`
+      : `${flow.name}.flow-meta.xml`,
+    filePath: flow.fsPath,
+    metadataType: "Flow",
+    content,
+    elements: toMetadataElements(flow),
+  };
+}
+
+/**
+ * Convert Flow elements to MetadataElements for element-level scanning.
+ */
+export function toMetadataElements(flow: Flow): MetadataElement[] {
+  if (!flow.elements || flow.elements.length === 0) {
+    return [];
+  }
+
+  return flow.elements.map((element) => ({
+    name: element.name,
+    type: element.subtype,
+    content: element.element ?? element,
+  }));
+}
+
+/**
+ * Convert a RegexViolation to a core Violation.
+ * Creates the appropriate FlowElement subclass based on metaType.
+ */
+export function toViolation(rv: RegexViolation): Violation {
+  // Create a FlowAttribute to represent the violation
+  // This is the simplest approach that works for all regex rules
+  const flowElement = new FlowAttribute(
+    rv.name,
+    rv.type,
+    rv.expression ?? rv.matchedText
+  );
+
+  const violation = new Violation(flowElement);
+
+  // Override line/column from regex violation
+  violation.lineNumber = rv.lineNumber;
+  violation.columnNumber = rv.columnNumber;
+
+  return violation;
+}
+
+/**
+ * Convert a core FlowElement to a regex-scanner MetadataElement.
+ */
+export function flowElementToMetadataElement(
+  element: FlowElement
+): MetadataElement {
+  return {
+    name: element.name,
+    type: element.subtype,
+    content: element.element ?? element,
+  };
+}
+
+/**
+ * Convert multiple RegexViolations to core Violations.
+ */
+export function toViolations(violations: RegexViolation[]): Violation[] {
+  return violations.map(toViolation);
+}

package/src/main/config/RuleRegistry.ts

@@ -0,0 +1,188 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import { IRuleConfig } from "../interfaces/IRuleConfig";
+import { IRulesConfig } from "../interfaces/IRulesConfig";
+// Import all rules
+import { ActionCallsInLoop } from "../rules/ActionCallsInLoop";
+import { APIVersion } from "../rules/APIVersion";
+import { AutoLayout } from "../rules/AutoLayout";
+import { CopyAPIName } from "../rules/CopyAPIName";
+import { CyclomaticComplexity } from "../rules/CyclomaticComplexity";
+import { DMLStatementInLoop } from "../rules/DMLStatementInLoop";
+import { DuplicateDMLOperation } from "../rules/DuplicateDMLOperation";
+import { FlowDescription } from "../rules/FlowDescription";
+import { FlowName } from "../rules/FlowName";
+import { GetRecordAllFields } from "../rules/GetRecordAllFields";
+import { HardcodedId } from "../rules/HardcodedId";
+import { HardcodedUrl } from "../rules/HardcodedUrl";
+import { HardcodedSecret } from "../rules/HardcodedSecret";
+import { InactiveFlow } from "../rules/InactiveFlow";
+import { MissingFaultPath } from "../rules/MissingFaultPath";
+import { MissingNullHandler } from "../rules/MissingNullHandler";
+import { ProcessBuilder } from "../rules/ProcessBuilder";
+import { RecursiveAfterUpdate } from "../rules/RecursiveAfterUpdate";
+import { SameRecordFieldUpdates } from "../rules/SameRecordFieldUpdates";
+import { SOQLQueryInLoop } from "../rules/SOQLQueryInLoop";
+import { TriggerOrder } from "../rules/TriggerOrder";
+import { UnconnectedElement } from "../rules/UnconnectedElement";
+import { UnsafeRunningContext } from "../rules/UnsafeRunningContext";
+import { UnusedVariable } from "../rules/UnusedVariable";
+import { MissingMetadataDescription } from "../rules/MissingMetadataDescription";
+import { MissingRecordTriggerFilter } from "../rules/MissingRecordTriggerFilter";
+import { TransformInsteadOfLoop } from "../rules/TransformInsteadOfLoop";
+import { RecordIdAsString } from "../rules/RecordIdAsString";
+
+type RuleConstructor = new () => IRuleDefinition;
+
+interface RuleRegistryEntry {
+  ruleId: string;
+  ruleClass: RuleConstructor;
+  legacyName: string;
+  isBeta: boolean;
+}
+
+class RuleRegistry {
+  private rules: Map<string, RuleRegistryEntry> = new Map();
+  private legacyNameMap: Map<string, string> = new Map();
+
+  register(
+    ruleId: string,
+    ruleClass: RuleConstructor,
+    legacyName: string,
+    isBeta: boolean = false
+  ): void {
+    const entry: RuleRegistryEntry = {
+      ruleId,
+      ruleClass,
+      legacyName,
+      isBeta,
+    };
+    this.rules.set(ruleId, entry);
+    this.legacyNameMap.set(legacyName, ruleId);
+  }
+
+  get(idOrLegacyName: string): RuleRegistryEntry | undefined {
+    let entry = this.rules.get(idOrLegacyName);
+    if (!entry) {
+      const ruleId = this.legacyNameMap.get(idOrLegacyName);
+      if (ruleId) {
+        entry = this.rules.get(ruleId);
+      }
+    }
+    return entry;
+  }
+
+  getAllRuleIds(includeBeta: boolean = false): string[] {
+    return Array.from(this.rules.values())
+      .filter(entry => includeBeta || !entry.isBeta)
+      .map(entry => entry.ruleId);
+  }
+
+  has(idOrLegacyName: string): boolean {
+    return this.get(idOrLegacyName) !== undefined;
+  }
+
+  createInstance(idOrLegacyName: string): IRuleDefinition {
+    const entry = this.get(idOrLegacyName);
+    if (!entry) {
+      throw new Error(`Rule not found: ${idOrLegacyName}`);
+    }
+    return new entry.ruleClass();
+  }
+
+  getRules(
+    ruleConfig?: Map<string, unknown>,
+    options?: IRulesConfig
+  ): IRuleDefinition[] {
+    const includeBeta = options?.betaMode === true || options?.betamode === true;
+    const rulesMode = options?.ruleMode || "merged";
+    const selectedRules: IRuleDefinition[] = [];
+
+    if (rulesMode === "isolated" && ruleConfig && ruleConfig.size > 0) {
+      for (const key of ruleConfig.keys()) {
+        const entry = this.get(key);
+        if (!entry) continue;
+
+        const config = ruleConfig.get(key) as IRuleConfig | undefined;
+        if (config?.enabled === false) continue;
+
+        const rule = this.createInstance(entry.ruleId);
+        if (config?.severity) {
+          rule.severity = config.severity;
+        }
+
+        selectedRules.push(rule);
+      }
+      return selectedRules;
+    }
+
+    const allRuleIds = this.getAllRuleIds(includeBeta);
+
+    for (const ruleId of allRuleIds) {
+      const rule = this.createInstance(ruleId);
+
+      const config = (
+        ruleConfig?.get(rule.ruleId) ??
+        ruleConfig?.get(rule.name)
+      ) as IRuleConfig | undefined;
+
+      if (config?.enabled === false) continue;
+      if (config?.severity) {
+        rule.severity = config.severity;
+      }
+
+      selectedRules.push(rule);
+    }
+
+    return selectedRules;
+  }
+
+  getRulesByNames(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[] {
+    if (!ruleNames || ruleNames.length === 0) {
+      return this.getRules(undefined, options);
+    }
+
+    const config = new Map<string, IRuleConfig>();
+    for (const identifier of ruleNames) {
+      const entry = this.get(identifier);
+      if (entry) {
+        config.set(entry.ruleId, { enabled: true });
+      }
+    }
+
+    return this.getRules(config, { ...options, ruleMode: "isolated" });
+  }
+}
+
+const registry = new RuleRegistry();
+
+registry.register("action-call-in-loop", ActionCallsInLoop, "ActionCallsInLoop");
+registry.register("invalid-api-version", APIVersion, "APIVersion");
+registry.register("missing-auto-layout", AutoLayout, "AutoLayout");
+registry.register("unclear-api-naming", CopyAPIName, "CopyAPIName");
+registry.register("excessive-cyclomatic-complexity", CyclomaticComplexity, "CyclomaticComplexity");
+registry.register("dml-in-loop", DMLStatementInLoop, "DMLStatementInLoop");
+registry.register("duplicate-dml", DuplicateDMLOperation, "DuplicateDMLOperation");
+registry.register("missing-flow-description", FlowDescription, "FlowDescription");
+registry.register("invalid-naming-convention", FlowName, "FlowName");
+registry.register("get-record-all-fields", GetRecordAllFields, "GetRecordAllFields");
+registry.register("hardcoded-id", HardcodedId, "HardcodedId");
+registry.register("hardcoded-url", HardcodedUrl, "HardcodedUrl");
+registry.register("inactive-flow", InactiveFlow, "InactiveFlow");
+registry.register("missing-fault-path", MissingFaultPath, "MissingFaultPath");
+registry.register("missing-null-handler", MissingNullHandler, "MissingNullHandler");
+registry.register("process-builder-usage", ProcessBuilder, "ProcessBuilder");
+registry.register("recursive-record-update", RecursiveAfterUpdate, "RecursiveAfterUpdate");
+registry.register("same-record-field-updates", SameRecordFieldUpdates, "SameRecordFieldUpdates");
+registry.register("soql-in-loop", SOQLQueryInLoop, "SOQLQueryInLoop");
+registry.register("unspecified-trigger-order", TriggerOrder, "TriggerOrder");
+registry.register("unreachable-element", UnconnectedElement, "UnconnectedElement");
+registry.register("unsafe-running-context", UnsafeRunningContext, "UnsafeRunningContext");
+registry.register("unused-variable", UnusedVariable, "UnusedVariable");
+
+registry.register("missing-metadata-description", MissingMetadataDescription, "MissingMetadataDescription", true);
+registry.register("missing-record-trigger-filter", MissingRecordTriggerFilter, "MissingFilterRecordTrigger", true);
+registry.register("transform-instead-of-loop", TransformInsteadOfLoop, "TransformInsteadOfLoop", true);
+registry.register("record-id-as-string", RecordIdAsString, "RecordIdAsString", true);
+registry.register("hardcoded-secret", HardcodedSecret, "HardcodedSecret", true);
+
+export const ruleRegistry = registry;

package/src/main/config/VariableIcons.ts

@@ -0,0 +1,57 @@
+/**
+ * Icon configuration for flow variable types.
+ * Includes icons for variable subtypes and boolean states.
+ */
+
+export interface VariableIconConfig {
+  // Variable subtype icons
+  subtypes: {
+    [subtype: string]: string;
+  };
+  // Boolean state icons (for isCollection, isInput, isOutput)
+  boolean: {
+    true: string;
+    false: string;
+  };
+}
+
+/**
+ * Default icons using emoji (recommended for modern environments)
+ */
+export const DEFAULT_VARIABLE_ICONS: VariableIconConfig = {
+  subtypes: {
+    variables: '\uD83D\uDCCA',        // BAR CHART (data/variable)
+    constants: '\uD83D\uDD12',        // LOCK (constant/immutable)
+    formulas: '\uD83E\uDDEE',         // ABACUS (calculation)
+    choices: '\uD83D\uDCCB',          // CLIPBOARD (picklist/choices)
+    dynamicChoiceSets: '\uD83D\uDD04', // ARROWS (dynamic)
+  },
+  boolean: {
+    true: '\u2705',                   // CHECK MARK
+    false: '\u2B1C',                  // WHITE SQUARE
+  }
+};
+
+/**
+ * ASCII fallback icons (for environments without emoji support)
+ */
+export const ASCII_VARIABLE_ICONS: VariableIconConfig = {
+  subtypes: {
+    variables: '[V]',
+    constants: '[C]',
+    formulas: '[F]',
+    choices: '[CH]',
+    dynamicChoiceSets: '[D]',
+  },
+  boolean: {
+    true: '[X]',
+    false: '[ ]',
+  }
+};
+
+/**
+ * Get default variable icon config
+ */
+export function getDefaultVariableIconConfig(): VariableIconConfig {
+  return DEFAULT_VARIABLE_ICONS;
+}

package/src/main/enums/MetadataTypes.ts

@@ -0,0 +1,6 @@
+export enum MetaType {
+  ATTRIBUTE = "attribute",
+  VARIABLE = "variable",
+  RESOURCE = "resource",
+  NODE = "node"
+}

package/src/main/interfaces/IExceptions.ts

@@ -0,0 +1,6 @@
+export interface IExceptions {
+  [exceptionName: string]: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    [property: string]: any[];
+  };
+}

package/src/main/interfaces/IRuleConfig.ts

@@ -0,0 +1,6 @@
+export interface IRuleConfig {
+  enabled?: boolean;
+  severity?: "error" | "warning" | "note";
+  message?: string; // Custom message to override rule description
+  messageUrl?: string; // Custom URL for documentation (auto-generated if not provided)
+}

package/src/main/interfaces/IRuleDefinition.ts

@@ -0,0 +1,15 @@
+import { Flow, RuleResult } from "../internals/internals";
+
+export interface IRuleDefinition {
+  ruleId: string;
+  description: string;
+  summary: string; // Short summary (5-10 words) shown when no custom message
+  docRefs: Array<{ label: string; path: string }>;
+  execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
+  isConfigurable: boolean;
+  label: string;
+  name: string;
+  severity?: string;
+  supportedTypes: string[];
+  uri?: string;
+}

package/src/main/interfaces/IRuleOptions.ts

@@ -0,0 +1,5 @@
+import { IRuleConfig } from "./IRuleConfig";
+
+export interface IRuleOptions {
+  [ruleName: string]: IRuleConfig;
+}

package/src/main/interfaces/IRulesConfig.ts

@@ -0,0 +1,17 @@
+import { IExceptions } from "./IExceptions";
+import { IRuleOptions } from "./IRuleOptions";
+
+export enum DetailLevel {
+  ENRICHED = 'enriched',
+  SIMPLE = 'simple'
+}
+
+export interface IRulesConfig {
+  betaMode?: boolean;  // Toggles beta rules; defaults to false
+  betamode?: boolean;  // Use betaMode instead; to be removed
+  detailLevel?: 'enriched' | 'simple' | DetailLevel;
+  exceptions?: IExceptions;
+  rules?: IRuleOptions;
+  ruleMode?: "merged" | "isolated"; // Defaults to "merged"
+  ignoreFlows?: string[]; // Flow API names to exclude from scanning
+}