@flow-scanner/lightning-flow-scanner-core 6.10.5 → 6.11.0

package/main/models/FlowNode.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "FlowNode", {
 const _MetadataTypes = require("../enums/MetadataTypes");
 const _FlowElement = require("./FlowElement");
 const _FlowElementConnector = require("./FlowElementConnector");
+const _NodeIcons = require("../config/NodeIcons");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -25,6 +26,146 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let FlowNode = class FlowNode extends _FlowElement.FlowElement {
+    /**
+   * Set custom icon configuration for all FlowNodes
+   * @example
+   * ```typescript
+   * // Use ASCII icons for old terminals
+   * FlowNode.setIconConfig(ASCII_ICONS);
+   * 
+   * // Or provide custom icons
+   * FlowNode.setIconConfig({
+   *   actionCalls: { default: '[ACTION]' },
+   *   decisions: { default: '[IF]' }
+   * });
+   * ```
+   */ static setIconConfig(config) {
+        FlowNode.iconConfig = config;
+    }
+    /**
+   * Use ASCII icons instead of emoji (for older browsers/terminals)
+   */ static useAsciiIcons() {
+        FlowNode.iconConfig = _NodeIcons.ASCII_ICONS;
+    }
+    /**
+   * Reset to default emoji icons
+   */ static useDefaultIcons() {
+        FlowNode.iconConfig = _NodeIcons.DEFAULT_ICONS;
+    }
+    extractTypeSpecificProperties(subtype, element) {
+        switch(subtype){
+            case "actionCalls":
+                this.actionType = element.actionType;
+                this.actionName = element.actionName;
+                break;
+            case "recordCreates":
+            case "recordUpdates":
+            case "recordDeletes":
+            case "recordLookups":
+                this.object = element.object;
+                this.inputReference = element.inputReference;
+                this.outputReference = element.outputReference;
+                break;
+            case "collectionProcessors":
+                this.elementSubtype = element.elementSubtype;
+                this.collectionReference = element.collectionReference;
+                break;
+            case "subflows":
+                this.flowName = element.flowName;
+                break;
+            case "decisions":
+                this.rules = Array.isArray(element.rules) ? element.rules : element.rules ? [
+                    element.rules
+                ] : [];
+                this.defaultConnectorLabel = element.defaultConnectorLabel;
+                break;
+            case "loops":
+                this.collectionReference = element.collectionReference;
+                this.iterationOrder = element.iterationOrder;
+                break;
+            case "screens":
+                this.fields = Array.isArray(element.fields) ? element.fields : element.fields ? [
+                    element.fields
+                ] : [];
+                this.allowPause = element.allowPause;
+                this.showFooter = element.showFooter;
+                break;
+        }
+    }
+    /**
+   * Get a human-readable summary of this node
+   */ getSummary() {
+        const parts = [];
+        switch(this.subtype){
+            case "actionCalls":
+                if (this.actionType) parts.push(this.prettifyValue(this.actionType));
+                if (this.actionName) parts.push(this.actionName);
+                break;
+            case "recordCreates":
+            case "recordUpdates":
+            case "recordDeletes":
+            case "recordLookups":
+                if (this.object) parts.push(this.object);
+                break;
+            case "collectionProcessors":
+                if (this.elementSubtype) parts.push(this.prettifyValue(this.elementSubtype));
+                break;
+            case "decisions":
+                var _this_rules, _this_rules1;
+                parts.push(`${((_this_rules = this.rules) === null || _this_rules === void 0 ? void 0 : _this_rules.length) || 0} rule${((_this_rules1 = this.rules) === null || _this_rules1 === void 0 ? void 0 : _this_rules1.length) !== 1 ? 's' : ''}`);
+                break;
+            case "loops":
+                if (this.collectionReference) parts.push(`Loop: ${this.collectionReference}`);
+                break;
+            case "subflows":
+                if (this.flowName) parts.push(this.flowName);
+                break;
+        }
+        if (this.description) {
+            parts.push(this.description.substring(0, 50) + (this.description.length > 50 ? '...' : ''));
+        }
+        return parts.join(' • ');
+    }
+    /**
+   * Get the icon for this node type
+   */ getIcon() {
+        const typeIcons = FlowNode.iconConfig[this.subtype];
+        if (!typeIcons) {
+            // Fallback for unknown types
+            const fallback = FlowNode.iconConfig['default'];
+            return fallback && 'default' in fallback ? fallback.default : '\u2022'; // • BULLET
+        }
+        // For nodes with subtypes (like actionCalls or collectionProcessors)
+        const subtype = this.actionType || this.elementSubtype;
+        const icons = typeIcons;
+        if (subtype && icons[subtype]) {
+            return icons[subtype];
+        }
+        return icons.default || '\u2022'; // • BULLET fallback
+    }
+    /**
+   * Get the display name for this node type
+   */ getTypeLabel() {
+        const labelMap = {
+            actionCalls: 'Action',
+            assignments: 'Assignment',
+            collectionProcessors: 'Collection',
+            customErrors: 'Error',
+            decisions: 'Decision',
+            loops: 'Loop',
+            recordCreates: 'Create',
+            recordDeletes: 'Delete',
+            recordLookups: 'Get Records',
+            recordUpdates: 'Update',
+            screens: 'Screen',
+            subflows: 'Subflow',
+            transforms: 'Transform'
+        };
+        return labelMap[this.subtype] || this.subtype;
+    }
+    prettifyValue(value) {
+        return value.replace(/([A-Z])/g, ' $1').replace(/^./, (str)=>str.toUpperCase()).trim();
+    }
     getConnectors(subtype, element) {
         const connectors = [];
         if (subtype === "start") {
@@ -160,10 +301,27 @@ let FlowNode = class FlowNode extends _FlowElement.FlowElement {
     }
     constructor(provName, subtype, element){
         const nodeName = subtype === "start" ? "flowstart" : provName;
-        super(_MetadataTypes.MetaType.NODE, subtype, nodeName, element), _define_property(this, "connectors", []), _define_property(this, "locationX", void 0), _define_property(this, "locationY", void 0);
-        const connectors = this.getConnectors(subtype, element);
-        this.connectors = connectors;
+        super(_MetadataTypes.MetaType.NODE, subtype, nodeName, element), _define_property(this, "connectors", []), _define_property(this, "locationX", void 0), _define_property(this, "locationY", void 0), // Common properties across node types
+        _define_property(this, "label", void 0), _define_property(this, "description", void 0), // Action-specific properties
+        _define_property(this, "actionType", void 0), _define_property(this, "actionName", void 0), // Record operation properties
+        _define_property(this, "object", void 0), _define_property(this, "inputReference", void 0), _define_property(this, "outputReference", void 0), // Collection processor properties
+        _define_property(this, "elementSubtype", void 0), _define_property(this, "collectionReference", void 0), // Subflow properties
+        _define_property(this, "flowName", void 0), // Decision properties
+        _define_property(this, "rules", void 0), _define_property(this, "defaultConnectorLabel", void 0), // Loop properties
+        _define_property(this, "iterationOrder", void 0), // Screen properties
+        _define_property(this, "fields", void 0), _define_property(this, "allowPause", void 0), _define_property(this, "showFooter", void 0), // Fault handling
+        _define_property(this, "faultConnector", void 0);
+        // Extract common properties
+        this.label = element["label"];
+        this.description = element["description"];
         this.locationX = element["locationX"];
         this.locationY = element["locationY"];
+        // Extract type-specific properties
+        this.extractTypeSpecificProperties(subtype, element);
+        // Extract connectors
+        this.connectors = this.getConnectors(subtype, element);
+        this.faultConnector = this.connectors.find((c)=>c.type === "faultConnector");
     }
 };
+// Static icon configuration (can be overridden)
+_define_property(FlowNode, "iconConfig", _NodeIcons.DEFAULT_ICONS);

package/main/models/FlowVariable.d.ts

@@ -1,5 +1,63 @@
 import { FlowElement } from "./FlowElement";
+import { type VariableIconConfig } from "../config/VariableIcons";
 export declare class FlowVariable extends FlowElement {
-    dataType: string;
+    dataType?: string;
+    isCollection?: boolean;
+    isInput?: boolean;
+    isOutput?: boolean;
+    objectType?: string;
+    description?: string;
+    value?: any;
+    private static iconConfig;
+    /**
+     * Set custom icon configuration for all FlowVariables
+     * @example
+     * ```typescript
+     * // Use ASCII icons
+     * FlowVariable.setIconConfig(ASCII_VARIABLE_ICONS);
+     *
+     * // Or provide custom icons
+     * FlowVariable.setIconConfig({
+     *   subtypes: {
+     *     variables: '[VAR]',
+     *     constants: '[CONST]'
+     *   },
+     *   boolean: {
+     *     true: '[YES]',
+     *     false: '[NO]'
+     *   }
+     * });
+     * ```
+     */
+    static setIconConfig(config: VariableIconConfig): void;
+    /**
+     * Use ASCII icons instead of emoji
+     */
+    static useAsciiIcons(): void;
+    /**
+     * Reset to default emoji icons
+     */
+    static useDefaultIcons(): void;
     constructor(name: string, subtype: string, element: object);
+    /**
+     * Get the icon for this variable subtype
+     */
+    getIcon(): string;
+    /**
+     * Get icon for a boolean value
+     */
+    private getBooleanIcon;
+    /**
+     * Get a human-readable type label
+     */
+    getTypeLabel(): string;
+    /**
+     * Get a markdown table row for this variable
+     */
+    toTableRow(): string;
+    /**
+     * Get a detailed markdown table for this variable
+     */
+    toMarkdownTable(): string;
+    private formatValue;
 }

package/main/models/FlowVariable.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "FlowVariable", {
 });
 const _MetadataTypes = require("../enums/MetadataTypes");
 const _FlowElement = require("./FlowElement");
+const _VariableIcons = require("../config/VariableIcons");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -24,8 +25,124 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let FlowVariable = class FlowVariable extends _FlowElement.FlowElement {
+    /**
+   * Set custom icon configuration for all FlowVariables
+   * @example
+   * ```typescript
+   * // Use ASCII icons
+   * FlowVariable.setIconConfig(ASCII_VARIABLE_ICONS);
+   * 
+   * // Or provide custom icons
+   * FlowVariable.setIconConfig({
+   *   subtypes: {
+   *     variables: '[VAR]',
+   *     constants: '[CONST]'
+   *   },
+   *   boolean: {
+   *     true: '[YES]',
+   *     false: '[NO]'
+   *   }
+   * });
+   * ```
+   */ static setIconConfig(config) {
+        FlowVariable.iconConfig = config;
+    }
+    /**
+   * Use ASCII icons instead of emoji
+   */ static useAsciiIcons() {
+        FlowVariable.iconConfig = _VariableIcons.ASCII_VARIABLE_ICONS;
+    }
+    /**
+   * Reset to default emoji icons
+   */ static useDefaultIcons() {
+        FlowVariable.iconConfig = _VariableIcons.DEFAULT_VARIABLE_ICONS;
+    }
+    /**
+   * Get the icon for this variable subtype
+   */ getIcon() {
+        return FlowVariable.iconConfig.subtypes[this.subtype] || '\uD83D\uDCCA'; // 📊 default
+    }
+    /**
+   * Get icon for a boolean value
+   */ getBooleanIcon(value) {
+        if (value === true) {
+            return FlowVariable.iconConfig.boolean.true;
+        } else if (value === false) {
+            return FlowVariable.iconConfig.boolean.false;
+        }
+        return ''; // undefined/null
+    }
+    /**
+   * Get a human-readable type label
+   */ getTypeLabel() {
+        const labelMap = {
+            variables: 'Variable',
+            constants: 'Constant',
+            formulas: 'Formula',
+            choices: 'Choice',
+            dynamicChoiceSets: 'Dynamic Choice'
+        };
+        return labelMap[this.subtype] || this.subtype;
+    }
+    /**
+   * Get a markdown table row for this variable
+   */ toTableRow() {
+        const parts = [
+            this.name,
+            this.dataType || '',
+            this.getBooleanIcon(this.isCollection),
+            this.getBooleanIcon(this.isInput),
+            this.getBooleanIcon(this.isOutput),
+            this.objectType || '',
+            this.description || ''
+        ];
+        return `| ${parts.join(' | ')} |`;
+    }
+    /**
+   * Get a detailed markdown table for this variable
+   */ toMarkdownTable() {
+        let table = '| Property | Value |\n|:---|:---|\n';
+        table += `| Name | ${this.name} |\n`;
+        table += `| Type | ${this.getIcon()} ${this.getTypeLabel()} |\n`;
+        if (this.dataType) table += `| Data Type | ${this.dataType} |\n`;
+        if (this.objectType) table += `| Object Type | ${this.objectType} |\n`;
+        if (this.isCollection !== undefined) {
+            table += `| Collection | ${this.getBooleanIcon(this.isCollection)} |\n`;
+        }
+        if (this.isInput !== undefined) {
+            table += `| Input | ${this.getBooleanIcon(this.isInput)} |\n`;
+        }
+        if (this.isOutput !== undefined) {
+            table += `| Output | ${this.getBooleanIcon(this.isOutput)} |\n`;
+        }
+        if (this.value !== undefined) {
+            table += `| Value | ${this.formatValue(this.value)} |\n`;
+        }
+        if (this.description) table += `| Description | ${this.description} |\n`;
+        return table;
+    }
+    formatValue(value) {
+        if (typeof value === 'object') {
+            return JSON.stringify(value, null, 2);
+        }
+        return String(value);
+    }
     constructor(name, subtype, element){
-        super(_MetadataTypes.MetaType.VARIABLE, subtype, name, element), _define_property(this, "dataType", void 0);
+        super(_MetadataTypes.MetaType.VARIABLE, subtype, name, element), _define_property(this, "dataType", void 0), _define_property(this, "isCollection", void 0), _define_property(this, "isInput", void 0), _define_property(this, "isOutput", void 0), _define_property(this, "objectType", void 0), _define_property(this, "description", void 0), _define_property(this, "value", void 0);
+        // Extract properties based on variable subtype
         this.dataType = element["dataType"];
+        this.isCollection = element["isCollection"];
+        this.isInput = element["isInput"];
+        this.isOutput = element["isOutput"];
+        this.objectType = element["objectType"];
+        this.description = element["description"];
+        // Different subtypes have different value properties
+        if (subtype === "constants") {
+            this.value = element["value"];
+        } else if (subtype === "formulas") {
+            this.value = element["expression"];
+        }
     }
 };
+// Static icon configuration (can be overridden)
+_define_property(FlowVariable, "iconConfig", _VariableIcons.DEFAULT_VARIABLE_ICONS);

package/main/models/LoopRuleCommon.js

@@ -12,7 +12,7 @@ const _internals = require("../internals/internals");
 const _RuleCommon = require("./RuleCommon");
 let LoopRuleCommon = class LoopRuleCommon extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        const loopElements = this.findLoopElements(flow);
+        const loopElements = flow.graph.getLoopNodes();
         if (!loopElements.length) {
             return [];
         }
@@ -21,25 +21,24 @@ let LoopRuleCommon = class LoopRuleCommon extends _RuleCommon.RuleCommon {
         return results;
     }
     findLoopElements(flow) {
-        var _flow_elements;
-        return ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "loops")) || [];
+        return flow.graph.getLoopNodes();
     }
     findLoopEnd(element) {
-        var _element_element_noMoreValuesConnector;
+        var _element_element_noMoreValuesConnector, _element_element;
         var _element_element_noMoreValuesConnector_targetReference;
-        return (_element_element_noMoreValuesConnector_targetReference = (_element_element_noMoreValuesConnector = element.element["noMoreValuesConnector"]) === null || _element_element_noMoreValuesConnector === void 0 ? void 0 : _element_element_noMoreValuesConnector.targetReference) !== null && _element_element_noMoreValuesConnector_targetReference !== void 0 ? _element_element_noMoreValuesConnector_targetReference : element.name;
+        return (_element_element_noMoreValuesConnector_targetReference = (_element_element = element.element) === null || _element_element === void 0 ? void 0 : (_element_element_noMoreValuesConnector = _element_element.noMoreValuesConnector) === null || _element_element_noMoreValuesConnector === void 0 ? void 0 : _element_element_noMoreValuesConnector.targetReference) !== null && _element_element_noMoreValuesConnector_targetReference !== void 0 ? _element_element_noMoreValuesConnector_targetReference : element.name;
     }
     findStatementsInLoops(flow, loopElements) {
         const statementsInLoops = [];
         const statementTypes = this.getStatementTypes();
-        const findStatement = (element)=>{
-            if (statementTypes.includes(element.subtype)) {
-                statementsInLoops.push(element);
-            }
-        };
         for (const element of loopElements){
-            const loopEnd = this.findLoopEnd(element);
-            new _internals.Compiler().traverseFlow(flow, element.name, findStatement, loopEnd);
+            const loopElems = flow.graph.getLoopElements(element.name);
+            for (const elemName of loopElems){
+                const node = flow.graph.getNode(elemName);
+                if (node && statementTypes.includes(node.subtype)) {
+                    statementsInLoops.push(node);
+                }
+            }
         }
         return statementsInLoops;
     }

package/main/models/ParsedFlow.d.ts

@@ -3,5 +3,5 @@ export declare class ParsedFlow {
     uri: string;
     flow: Flow | undefined;
     errorMessage?: string;
-    constructor(uri: string, flow: Flow, errorMessage?: string);
+    constructor(uri: string, flow?: Flow, errorMessage?: string);
 }

package/main/models/RuleCommon.d.ts

@@ -16,17 +16,40 @@ export declare abstract class RuleCommon {
     constructor(info: RuleInfo, optional?: {
         severity?: string;
     });
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected abstract check(flow: core.Flow, options: object | undefined, suppressions: Set<string>): core.Violation[];
+    protected isSuppressed(name: string, suppressions: Set<string>): boolean;
     /**
-     * execute() – automatic suppression
+     * Get the start node (the special <start> element).
+     * This is now stored separately in flow.startNode, not in flow.elements.
+     *
+     * @param flow - The Flow instance
+     * @returns The start FlowNode or undefined if not found
      */
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected getStartNode(flow: core.Flow): core.FlowNode | undefined;
     /**
-     * Rules implement this. They should return *all* violations,
-     * NOT pre-filter suppressed ones (unless they need early-exit performance).
+     * Get the reference name of the first actual element (what the flow starts at).
+     * This is the element that comes AFTER the start node.
+     *
+     * @param flow - The Flow instance
+     * @returns The start reference name or undefined
      */
-    protected abstract check(flow: core.Flow, options: object | undefined, suppressions: Set<string>): core.Violation[];
+    protected getStartReference(flow: core.Flow): string | undefined;
     /**
-     * Legacy/manual suppression helper (still available for early exits)
+     * Find the INDEX of the first actual element in a FlowNode array.
+     * Useful for rules that need to iterate by index.
+     *
+     * @param flow - The Flow instance
+     * @param flowElements - Array of FlowNodes (typically from flow.elements)
+     * @returns The index of the starting element, or -1 if not found
      */
-    protected isSuppressed(name: string, suppressions: Set<string>): boolean;
+    protected findStartIndex(flow: core.Flow, flowElements: core.FlowNode[]): number;
+    /**
+     * Safely get a property from the start element.
+     *
+     * @param flow - The Flow instance
+     * @param propertyName - The property to retrieve (e.g., 'triggerType', 'object')
+     * @returns The property value or undefined
+     */
+    protected getStartProperty(flow: core.Flow, propertyName: string): any;
 }

package/main/models/RuleCommon.js

@@ -64,31 +64,69 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let RuleCommon = class RuleCommon {
-    /**
-   * execute() – automatic suppression
-   */ execute(flow, options, suppressions = []) {
+    execute(flow, options, suppressions = []) {
         // Wildcard suppression disables entire rule
         if (suppressions.includes("*")) {
             return new _internals.RuleResult(this, []);
         }
-        // Convert to Set for fast lookup
         const suppSet = new Set(suppressions);
-        // Raw violations from rule
         let violations = this.check(flow, options, suppSet);
-        // Automatically filter suppressed violations by their .name
         violations = violations.filter((v)=>!suppSet.has(v.name));
-        // Wrap into RuleResult
         return new _internals.RuleResult(this, violations);
     }
-    /**
-   * Legacy/manual suppression helper (still available for early exits)
-   */ isSuppressed(name, suppressions) {
+    isSuppressed(name, suppressions) {
         return suppressions.has(name);
     }
+    /**
+   * Get the start node (the special <start> element).
+   * This is now stored separately in flow.startNode, not in flow.elements.
+   * 
+   * @param flow - The Flow instance
+   * @returns The start FlowNode or undefined if not found
+   */ getStartNode(flow) {
+        return flow.startNode;
+    }
+    /**
+   * Get the reference name of the first actual element (what the flow starts at).
+   * This is the element that comes AFTER the start node.
+   * 
+   * @param flow - The Flow instance
+   * @returns The start reference name or undefined
+   */ getStartReference(flow) {
+        return flow.startReference || undefined;
+    }
+    /**
+   * Find the INDEX of the first actual element in a FlowNode array.
+   * Useful for rules that need to iterate by index.
+   * 
+   * @param flow - The Flow instance
+   * @param flowElements - Array of FlowNodes (typically from flow.elements)
+   * @returns The index of the starting element, or -1 if not found
+   */ findStartIndex(flow, flowElements) {
+        const startRef = this.getStartReference(flow);
+        if (!startRef) {
+            return -1;
+        }
+        return flowElements.findIndex((n)=>n.name === startRef);
+    }
+    /**
+   * Safely get a property from the start element.
+   * 
+   * @param flow - The Flow instance
+   * @param propertyName - The property to retrieve (e.g., 'triggerType', 'object')
+   * @returns The property value or undefined
+   */ getStartProperty(flow, propertyName) {
+        var _flow_startNode;
+        if ((_flow_startNode = flow.startNode) === null || _flow_startNode === void 0 ? void 0 : _flow_startNode.element) {
+            var _flow_startNode_element;
+            return (_flow_startNode_element = flow.startNode.element) === null || _flow_startNode_element === void 0 ? void 0 : _flow_startNode_element[propertyName];
+        }
+        return undefined;
+    }
     constructor(info, optional){
         _define_property(this, "description", void 0);
         _define_property(this, "docRefs", []);
-        _define_property(this, "isConfigurable", void 0); // Auto-detected by checking if the implemented check() method actually uses "options."
+        _define_property(this, "isConfigurable", void 0);
         _define_property(this, "label", void 0);
         _define_property(this, "name", void 0);
         _define_property(this, "severity", void 0);

package/main/rules/APIVersion.js

@@ -65,7 +65,37 @@ let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
         }
         // Custom logic
         if (options === null || options === void 0 ? void 0 : options.expression) {
-            const isValid = new Function(`return ${flowAPIVersionNumber}${options.expression};`)();
+            // Match something like: >= 58
+            const match = options.expression.match(/^\s*(>=|<=|>|<|===|!==)\s*(\d+)\s*$/);
+            if (!match) {
+                // Invalid expression format
+                return [
+                    new _internals.Violation(new _internals.FlowAttribute("Invalid API rule expression", "apiVersion", options.expression))
+                ];
+            }
+            const [, operator, versionStr] = match;
+            const target = parseFloat(versionStr);
+            let isValid = true;
+            switch(operator){
+                case ">":
+                    isValid = flowAPIVersionNumber > target;
+                    break;
+                case "<":
+                    isValid = flowAPIVersionNumber < target;
+                    break;
+                case ">=":
+                    isValid = flowAPIVersionNumber >= target;
+                    break;
+                case "<=":
+                    isValid = flowAPIVersionNumber <= target;
+                    break;
+                case "===":
+                    isValid = flowAPIVersionNumber === target;
+                    break;
+                case "!==":
+                    isValid = flowAPIVersionNumber !== target;
+                    break;
+            }
             if (!isValid) {
                 return [
                     new _internals.Violation(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression))

package/main/rules/DuplicateDMLOperation.d.ts

@@ -4,6 +4,5 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class DuplicateDMLOperation extends RuleCommon implements IRuleDefinition {
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
-    private findStart;
-    private flagDML;
+    private isDML;
 }