@flow-scanner/lightning-flow-scanner-core 6.0.3

package/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+## Contributing Guidelines
+
+Since 2021, the _Lightning Flow Scanner_ has grown from its roots as VS Code tool to empower Salesforce Developers across six free and open-source platforms—from developer tools to native Salesforce App—delivering a unified experience for robust static analysis of Flows. Our dedicated community has shared their expertise to deepen understanding of Flow optimization. Your support can amplify our impact. Here’s how you can contribute:
+
+- ⭐ Starring the project to show your support
+- 📢 Sharing our work with your network
+- 💬 Sharing feedback to help us improve
+- 💻 Contributing code to drive innovation
+
+### I have a Question/Feedback
+
+For general questions, ideas, or seeking input on topics that might (or might not) turn into issues, we recommend to use our [Discussions](https://github.com/orgs/Flow-Scanner/discussions) forum. This is best for open-ended conversations, brainstorming, and gathering community input before creating a feature request.
+
+If it's more specific like a bug or a new feature—use [GitHub Issues](https://github.com/features/issues) instead. Before creating a new issue, please take a moment to search the existing [Issues](/issues) to prevent duplicates. If you find something relevant, adding an upvote helps us understand demand and prioritize better. We've prepared a few templates to guide you through the process of issue reporting:
+
+###### Core Engine - For issues or requests related to the core functionality of the scanner, use the following links to submit your request:
+
+- [Report Issue](https://github.com/Flow-Scanner/lightning-flow-scanner-core/issues/new?template=bug_report.md): Report a bug or issue.
+- [Rule Request](https://github.com/Flow-Scanner/lightning-flow-scanner-core/issues/new?template=rule-request.md): Submit a request for a new rule.
+- [Features/Other](https://github.com/Flow-Scanner/lightning-flow-scanner-core/issues/new): Suggest a new feature.
+
+###### Platforms - For issues or requests related to specific platforms, use the appropriate link below:
+
+- [CLI Plugin](https://github.com/Flow-Scanner/lightning-flow-scanner-cli/issues/new)
+- [Copado Plugin](https://github.com/Flow-Scanner/lightning-flow-scanner-copado/issues/new)
+- [GitHub Action](https://github.com/Flow-Scanner/lightning-flow-scanner-action/issues/new)
+- [Salesforce App](https://github.com/Flow-Scanner/lightning-flow-scanner-app/issues/new)
+- [VS Code/Code Builder](https://github.com/Flow-Scanner/lightning-flow-scanner-vsx/issues/new)
+
+###### Thank you

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ruben Halman, Jun Jose and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,314 @@
+<p align="center">
+  <a href="https://github.com/Flow-Scanner">
+    <img src="assets/media/bannerslim.png" style="width: 43%;" />
+  </a>
+</p>
+
+<p align="center"><i>A plug-and-play engine for Flow metadata in Node.js & browsers—with 20+ rules to catch unsafe contexts, loop queries, hardcoded IDs, and more.</i></p>
+
+- [Default Rules](#default-rules)
+- [Configuration](#configuration)
+  - [Defining Severity Levels](#defining-severity-levels)
+  - [Configuring Expressions](#configuring-expressions)
+  - [Specifying Exceptions](#specifying-exceptions)
+  - [Include Beta Rules](#include-beta-rules)
+- [Usage](#Usage)
+  - [Installation](#installation)
+  - [Core Functions](#core-functions)
+- [Development](#development)
+
+---
+
+## Default Rules
+
+<p>📌 <strong>Tip:</strong> To link directly to a specific rule, use the full GitHub anchor link format. Example:</p>
+<p><em><a href="https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context">https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context</a></em></i></p>
+
+### Action Calls In Loop
+
+_[ActionCallsInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/ActionCallsInLoop.ts)_ - To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilizing a single action call containing a collection variable at the end of the loop.
+
+### Outdated API Version
+
+_[APIVersion](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/APIVersion.ts)_ - Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the **Api Version** attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.
+
+### Auto Layout
+
+_[AutoLayout](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/AutoLayout.ts)_ - With Canvas Mode set to Auto‑Layout, elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized—saving you time.
+
+### Copy API Name
+
+_[CopyAPIName](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/CopyAPIName.ts)_ - Maintaining multiple elements with a similar name, like `Copy_X_Of_Element`, can diminish the overall readability of your Flow. When copying and pasting these elements, remember to update the API name of the newly created copy.
+
+### Cyclomatic Complexity
+
+_[CyclomaticComplexity](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/CyclomaticComplexity.ts)_ - The number of loops and decision rules, plus the number of decisions. Use a combination of 1) subflows and 2) breaking flows into multiple concise trigger‑ordered flows to reduce cyclomatic complexity within a single flow, ensuring maintainability and simplicity.
+
+### DML Statement In A Loop
+
+_[DMLStatementInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/DMLStatementInLoop.ts)_ - To prevent exceeding Apex governor limits, consolidate all your database operations—record creation, updates, or deletions—at the conclusion of the flow.
+
+### Duplicate DML Operation
+
+_[DuplicateDMLOperation](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/DuplicateDMLOperation.ts)_ - When a flow executes database changes or actions between two screens, prevent users from navigating backward between screens; otherwise, duplicate database operations may be performed.
+
+### Flow Naming Convention
+
+_[FlowName](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/FlowName.ts)_ - The readability of a flow is paramount. Establishing a naming convention significantly enhances findability, searchability, and overall consistency. Include at least a domain and a brief description of the flow’s actions, for example `Service_OrderFulfillment`.
+
+### Get Record All Fields
+
+_[GetRecordAllFields](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/GetRecordAllFields.ts)_ - Following the principle of least privilege (PoLP), avoid using **Get Records** with “Automatically store all fields” unless necessary.
+
+### Hardcoded Id
+
+_[HardcodedId](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/HardcodedId.ts)_ - Avoid hard‑coding IDs because they are org specific. Instead, pass them into variables at the start of the flow—via merge‑field URL parameters or a **Get Records** element.
+
+### Hardcoded Url
+
+_[HardcodedUrl](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/HardcodedUrl.ts)_ - Avoid hard‑coding URLs because they are environment specific. Use an `$API` formula (preferred) or environment‑specific sources like custom labels, metadata, or settings.
+
+### Inactive Flow
+
+_[InactiveFlow](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/InactiveFlow.ts)_ - Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble—such as accidentally deleting records during testing, or being activated as subflows.
+
+### Missing Fault Path
+
+_[MissingFaultPath](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/MissingFaultPath.ts)_ - A flow may fail to execute an operation as intended. By default, the flow displays an error to the user and emails the creator. Customize this behavior by incorporating a Fault Path.
+
+### Missing Flow Description
+
+_[FlowDescription](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/FlowDescription.ts)_ - Descriptions play a vital role in documentation. We highly recommend including details about where flows are used and their intended purpose.
+
+### Missing Null Handler
+
+_[MissingNullHandler](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/MissingNullHandler.ts)_ - When a **Get Records** operation finds no data, it returns `null`. Validate data by using a Decision element to check for a non‑null result.
+
+### Process Builder
+
+_[ProcessBuilder](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/ProcessBuilder.ts)_ - Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Begin migrating your organization’s automation to Flow.
+
+### Recursive After Update
+
+_[RecursiveAfterUpdate](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/RecursiveAfterUpdate.ts)_ - After‑update flows are meant for modifying **other** records. Using them on the same record can cause recursion. Consider **before‑save** flows for same‑record updates.
+
+### Same Record Field Updates
+
+_[SameRecordFieldUpdates](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/SameRecordFieldUpdates.ts)_ - Similar to triggers, **before‑save** contexts can update the same record via `$Record` without invoking DML.
+
+### SOQL Query In A Loop
+
+_[SOQLQueryInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/SOQLQueryInLoop.ts)_ - To prevent exceeding Apex governor limits, consolidate all SOQL queries at the end of the flow.
+
+### Trigger Order
+
+_[TriggerOrder](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/TriggerOrder.ts)_ - Guarantee your flow execution order with the **Trigger Order** property introduced in Spring ’22.
+
+### Unconnected Element
+
+_[UnconnectedElement](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/UnconnectedElement.ts)_ - Avoid unconnected elements that are not used by the flow to keep flows efficient and maintainable.
+
+### Unsafe Running Context
+
+_[UnsafeRunningContext](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/UnsafeRunningContext.ts)_ - This flow is configured to run in **System Mode without Sharing**, granting all users permission to view and edit all data. This can lead to unsafe data access.
+
+### Unused Variable
+
+_[UnusedVariable](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/UnusedVariable.ts)_ - To maintain efficiency and manageability, avoid including variables that are never referenced.
+
+---
+
+## Configuration
+
+It is recommended to set up configuration and define:
+
+- The rules to be executed.
+- The severity of violating any specific rule.
+- Rule properties such as REGEX expressions.
+- Any known exceptions that should be ignored during scanning.
+
+```json
+{
+  "rules": {
+    // Your rules here
+  },
+  "exceptions": {
+    // Your exceptions here
+  }
+}
+```
+
+Using the rules section of your configurations, you can specify the list of rules to be run. Furthermore, you can define the severity and configure expressions of rules. To include rules currently that are currently in beta, set `betarules` to true. Below is a breakdown of the available attributes of rule configuration:
+
+```json
+{
+  "rules": {
+    "<RuleName>": {
+      "severity": "<Severity>",
+      "expression": "<Expression>"
+    }
+  }
+}
+```
+
+### Defining Severity Levels
+
+When the severity is not provided it will be `warning` by default. Other available values for severity are `error` and `note`. Define the severity per rule as shown below:
+
+```json
+{
+  "rules": {
+    "FlowDescription": {
+      "severity": "error"
+    },
+    "UnusedVariable": {
+      "severity": "note"
+    }
+  }
+}
+```
+
+### Configuring Expressions
+
+Some rules have additional attributes to configure, such as the expression, that will overwrite default values. These can be configured in the same way as severity as shown in the following example.
+
+```json
+{
+  "rules": {
+    "APIVersion": {
+      "severity": "error",
+      "expression": "===58"
+    },
+    "FlowName": {
+      "severity": "note",
+      "expression": "[A-Za-z0-9]"
+    }
+  }
+}
+```
+
+### Specifying Exceptions
+
+Specifying exceptions allows you to exclude specific scenarios from rule enforcement. Exceptions can be specified at the flow, rule, or result level to provide fine-grained control. Below is a breakdown of the available attributes of exception configuration:
+
+```json
+{
+  "exceptions": {
+    "<FlowName>": {
+      "<RuleName>": [
+        "<ResultName>",
+        "<ResultName>",
+        ...
+      ]
+    },
+    ...
+  }
+}
+```
+
+### Include Beta Rules
+
+New rules are introduced in Beta mode before being added to the default ruleset. To include current Beta rules, enable the optional betamode parameter in your configuration:
+
+```json
+{
+  "rules": {
+    ...
+  },
+  "exceptions": {
+    ...
+  },
+  "betamode": true
+}
+```
+
+---
+
+## Usage
+
+### Installation
+
+The Lightning Flow Scanner Core can be used as a dependency in Node.js and browser environments, or used as a standalone UMD module. To install:
+
+```bash
+npm install @flow-scanner/lightning-flow-scanner-core
+```
+
+### Core Functions
+
+#### [`getRules(ruleNames?: string[]): IRuleDefinition[]`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/GetRuleDefinitions.ts)
+
+_Retrieves rule definitions used in the scanner._
+
+#### [`parse(selectedUris: any): Promise<ParsedFlow[]>`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/ParseFlows.ts)
+
+_Parses metadata from selected Flow files._
+
+#### [`scan(parsedFlows: ParsedFlow[], ruleOptions?: IRulesConfig): ScanResult[]`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/ScanFlows.ts)
+
+_Runs rules against parsed flows and returns scan results._
+
+#### [`fix(results: ScanResult[]): ScanResult[]`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/FixFlows.ts)
+
+_Attempts to apply automatic fixes where available._
+
+---
+
+## Development
+
+> This project optionally uses [Volta](https://volta.sh) to manage Node.js versions. Install Volta with:
+>
+> ```sh
+> curl https://get.volta.sh | bash
+> ```
+>
+> Volta will automatically use the Node.js version defined in `package.json`.
+
+1. Clone the repo:
+
+   ```bash
+   git clone https://github.com/Flow-Scanner/lightning-flow-scanner-core.git
+   ```
+
+2. Install dependencies:
+
+   ```bash
+   npm install
+   ```
+
+3. Build the project:
+
+   ```bash
+   npm run build
+   ```
+
+4. Run tests:
+
+   ```bash
+   npm run test
+   ```
+
+5. Test as local dependency(Optional):
+   To test changes to the core module in the VS Code extension or SF CLI plugin locally, run:
+
+   ```bash
+   npm run link
+   ```
+
+   b) Go to the dependent project (VSX or SF CLI) and use:
+
+   ```bash
+   npm link @flow-scanner/lightning-flow-scanner-core
+   ```
+
+   Your local core module will now replace the installed dependency and update automatically on rebuild.
+
+6. Create a standalone UMD Module(Optional):
+
+```bash
+npm run vite:dist
+```
+
+The resulting file will be available in the `dist` directory as `lightning-flow-scanner-core.umd.js`.
+
+###### Want to help improve Lightning Flow Scanner? See our [Contributing Guidelines](https://github.com/Flow-Scanner/lightning-flow-scanner-core/blob/main/CONTRIBUTING.md).

package/SECURITY.md

@@ -0,0 +1,26 @@
+# Security Policy for Lightning Flow Scanner
+
+## Security Practices
+
+- Code is open-source and peer-reviewed by the community.
+- Vulnerabilities can be reported privately via GitHub security features.
+- Changes to the repository are scanned and reviewed before merging.
+- Tokenless Publishing with scoped npm packages and releases via GitHub Actions Trusted Publishing (OIDC).
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability, please report it using [GitHub vulnerability reporting](https://github.com/Flow-Scanner/lightning-flow-scanner-core/security).
+
+## Data Handling
+
+This tool collects zero user data. No credentials, PII, payment info, health data, or user content is ever stored, transmitted, or shared. All analysis runs 100% client-side with no network calls to external services.
+
+We temporarily use metadata (e.g., Flow metadata, timestamps) in-memory only for real-time functionality during your session. This data is never stored, logged, or transmitted and is discarded immediately when the session ends.
+
+## Dependencies
+
+We actively track and maintain an up-to-date inventory of all third-party dependencies to ensure security and compatibility. Our dependencies include:
+
+| Package           | License                                                                           | Purpose                                        |
+| ----------------- | --------------------------------------------------------------------------------- | ---------------------------------------------- |
+| `fast-xml-parser` | [MIT](https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/LICENSE) | Validate XML, Parse XML and Build XML rapidly. |

package/index.d.ts

@@ -0,0 +1,21 @@
+import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
+import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
+import { Compiler } from "./main/libs/Compiler";
+import { fix } from "./main/libs/FixFlows";
+import { getBetaRules, getRules } from "./main/libs/GetRuleDefinitions";
+import { parse } from "./main/libs/ParseFlows";
+import { scan } from "./main/libs/ScanFlows";
+import { AdvancedRule } from "./main/models/AdvancedRule";
+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 { ResultDetails } from "./main/models/ResultDetails";
+import { RuleResult } from "./main/models/RuleResult";
+import { ScanResult } from "./main/models/ScanResult";
+export { AdvancedRule, Compiler, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, ResultDetails, RuleResult, scan, ScanResult, };
+export type { IRuleDefinition, IRulesConfig };

package/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get AdvancedRule () {
+        return _AdvancedRule.AdvancedRule;
+    },
+    get Compiler () {
+        return _Compiler.Compiler;
+    },
+    get Flow () {
+        return _Flow.Flow;
+    },
+    get FlowAttribute () {
+        return _FlowAttribute.FlowAttribute;
+    },
+    get FlowElement () {
+        return _FlowElement.FlowElement;
+    },
+    get FlowNode () {
+        return _FlowNode.FlowNode;
+    },
+    get FlowResource () {
+        return _FlowResource.FlowResource;
+    },
+    get FlowType () {
+        return _FlowType.FlowType;
+    },
+    get FlowVariable () {
+        return _FlowVariable.FlowVariable;
+    },
+    get ParsedFlow () {
+        return _ParsedFlow.ParsedFlow;
+    },
+    get ResultDetails () {
+        return _ResultDetails.ResultDetails;
+    },
+    get RuleResult () {
+        return _RuleResult.RuleResult;
+    },
+    get ScanResult () {
+        return _ScanResult.ScanResult;
+    },
+    get fix () {
+        return _FixFlows.fix;
+    },
+    get getBetaRules () {
+        return _GetRuleDefinitions.getBetaRules;
+    },
+    get getRules () {
+        return _GetRuleDefinitions.getRules;
+    },
+    get parse () {
+        return _ParseFlows.parse;
+    },
+    get scan () {
+        return _ScanFlows.scan;
+    }
+});
+const _Compiler = require("./main/libs/Compiler");
+const _FixFlows = require("./main/libs/FixFlows");
+const _GetRuleDefinitions = require("./main/libs/GetRuleDefinitions");
+const _ParseFlows = require("./main/libs/ParseFlows");
+const _ScanFlows = require("./main/libs/ScanFlows");
+const _AdvancedRule = require("./main/models/AdvancedRule");
+const _Flow = require("./main/models/Flow");
+const _FlowAttribute = require("./main/models/FlowAttribute");
+const _FlowElement = require("./main/models/FlowElement");
+const _FlowNode = require("./main/models/FlowNode");
+const _FlowResource = require("./main/models/FlowResource");
+const _FlowType = require("./main/models/FlowType");
+const _FlowVariable = require("./main/models/FlowVariable");
+const _ParsedFlow = require("./main/models/ParsedFlow");
+const _ResultDetails = require("./main/models/ResultDetails");
+const _RuleResult = require("./main/models/RuleResult");
+const _ScanResult = require("./main/models/ScanResult");

package/main/interfaces/AdvancedRuleConfig.d.ts

@@ -0,0 +1,11 @@
+export type AdvancedConfig = {
+    disabled?: boolean;
+    expression?: {
+        [key: string]: number | string;
+    };
+    severity?: string;
+    suppressions?: string[];
+};
+export type AdvancedRuleConfig = {
+    [ruleName: string]: AdvancedConfig;
+};

package/main/interfaces/AdvancedRuleConfig.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/AdvancedRuleDefintion.d.ts

@@ -0,0 +1,5 @@
+import { Flow, RuleResult } from "../internals/internals";
+import { AdvancedConfig } from "./AdvancedRuleConfig";
+export interface AdvancedRuleDefinition {
+    execute2(flow: Flow, ruleConfiguration?: AdvancedConfig, userFlowSuppressions?: string[]): RuleResult;
+}

package/main/interfaces/AdvancedRuleDefintion.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/AdvancedSuppression.d.ts

@@ -0,0 +1,21 @@
+import { RuleResult } from "../models/RuleResult";
+import { AdvancedConfig } from "./AdvancedRuleConfig";
+/**
+ * Interface for implementing advanced suppression logic on rule scan results.
+ *
+ * @remarks
+ * This interface defines a contract for classes or objects that provide suppression capabilities
+ * for rule results, potentially modifying or filtering the results based on custom logic and optional configuration.
+ *
+ * @interface
+ */
+export interface AdvancedSuppression {
+    /**
+     * Suppresses or modifies a given rule scan result based on advanced configuration.
+     *
+     * @param scanResult - The result of a rule scan to be potentially suppressed or altered.
+     * @param ruleConfiguration - Optional advanced configuration that may influence suppression logic.
+     * @returns The (potentially) suppressed or modified rule result.
+     */
+    suppress(scanResult: RuleResult, ruleConfiguration?: AdvancedConfig): RuleResult;
+}

package/main/interfaces/AdvancedSuppression.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/AutoFixable.d.ts

@@ -0,0 +1,10 @@
+import { Flow } from "../internals/internals";
+/**
+ * Interface representing an entity capable of automatically fixing a Flow.
+ *
+ * Implementations of this interface provide a `fix` method that takes a {@link Flow}
+ * object as input and returns a new or modified {@link Flow} with applied fixes.
+ */
+export interface AutoFixable {
+    fix(flow: Flow): Flow;
+}

package/main/interfaces/AutoFixable.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/IExceptions.d.ts

@@ -0,0 +1,5 @@
+export interface IExceptions {
+    [exceptionName: string]: {
+        [property: string]: any[];
+    };
+}

package/main/interfaces/IExceptions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/IRuleConfig.d.ts

@@ -0,0 +1,3 @@
+export interface IRuleConfig {
+    severity?: string;
+}

package/main/interfaces/IRuleConfig.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/IRuleDefinition.d.ts

@@ -0,0 +1,17 @@
+import { Flow } from "../models/Flow";
+import { RuleResult } from "../models/RuleResult";
+export interface IRuleDefinition {
+    autoFixable: boolean;
+    description: string;
+    docRefs: Array<{
+        label: string;
+        path: string;
+    }>;
+    execute(flow: Flow, ruleOptions?: {}): RuleResult;
+    isConfigurable: boolean;
+    label: string;
+    name: string;
+    severity?: string;
+    supportedTypes: string[];
+    uri?: string;
+}

package/main/interfaces/IRuleDefinition.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/IRuleOptions.d.ts

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

package/main/interfaces/IRuleOptions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/interfaces/IRulesConfig.d.ts

@@ -0,0 +1,8 @@
+import { AdvancedRuleConfig } from "./AdvancedRuleConfig";
+import { IExceptions } from "./IExceptions";
+import { IRuleOptions } from "./IRuleOptions";
+export interface IRulesConfig {
+    betamode?: boolean;
+    exceptions?: IExceptions;
+    rules?: AdvancedRuleConfig | IRuleOptions;
+}

package/main/interfaces/IRulesConfig.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});