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

package/main/rules/CyclomaticComplexity.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CyclomaticComplexity", {
+    enumerable: true,
+    get: function() {
+        return CyclomaticComplexity;
+    }
+});
+const _AdvancedRule = require("../models/AdvancedRule");
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let CyclomaticComplexity = class CyclomaticComplexity extends _AdvancedRule.AdvancedRule {
+    execute(flow, options) {
+        var _flow_elements, _flow_elements1;
+        // Set Threshold
+        const threshold = (options === null || options === void 0 ? void 0 : options.threshold) || this.defaultThreshold;
+        // Calculate Cyclomatic Complexity based on the number of decision rules and loops, adding the number of decisions plus 1.
+        let cyclomaticComplexity = 1;
+        const flowDecisions = flow === null || flow === void 0 ? void 0 : (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "decisions");
+        const flowLoops = flow === null || flow === void 0 ? void 0 : (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : _flow_elements1.filter((node)=>node.subtype === "loops");
+        for (const decision of flowDecisions || []){
+            const rules = decision.element["rules"];
+            if (Array.isArray(rules)) {
+                cyclomaticComplexity += rules.length + 1;
+            } else {
+                cyclomaticComplexity += 1;
+            }
+        }
+        var _flowLoops_length;
+        cyclomaticComplexity += (_flowLoops_length = flowLoops === null || flowLoops === void 0 ? void 0 : flowLoops.length) !== null && _flowLoops_length !== void 0 ? _flowLoops_length : 0;
+        this.cyclomaticComplexityUnit = cyclomaticComplexity; // for unit testing
+        const results = [];
+        if (cyclomaticComplexity > threshold) {
+            results.push(new _internals.ResultDetails(new _internals.FlowAttribute(`${cyclomaticComplexity}`, "CyclomaticComplexity", `>${threshold}`)));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "CyclomaticComplexity",
+            label: "Cyclomatic Complexity",
+            description: `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 the cyclomatic complexity within a single flow, ensuring maintainability and simplicity.`,
+            supportedTypes: _internals.FlowType.backEndTypes,
+            docRefs: [
+                {
+                    label: `Cyclomatic complexity is a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program's source code.`,
+                    path: "https://en.wikipedia.org/wiki/Cyclomatic_complexity"
+                }
+            ],
+            isConfigurable: true,
+            autoFixable: false
+        }, {
+            severity: "note"
+        }), _define_property(this, "defaultThreshold", 25), _define_property(this, "cyclomaticComplexityUnit", 0);
+    }
+};

package/main/rules/DMLStatementInLoop.d.ts

@@ -0,0 +1,6 @@
+import { IRuleDefinition } from "../internals/internals";
+import { LoopRuleCommon } from "../models/LoopRuleCommon";
+export declare class DMLStatementInLoop extends LoopRuleCommon implements IRuleDefinition {
+    constructor();
+    protected getStatementTypes(): string[];
+}

package/main/rules/DMLStatementInLoop.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DMLStatementInLoop", {
+    enumerable: true,
+    get: function() {
+        return DMLStatementInLoop;
+    }
+});
+const _internals = require("../internals/internals");
+const _LoopRuleCommon = require("../models/LoopRuleCommon");
+let DMLStatementInLoop = class DMLStatementInLoop extends _LoopRuleCommon.LoopRuleCommon {
+    getStatementTypes() {
+        return [
+            "recordDeletes",
+            "recordUpdates",
+            "recordCreates"
+        ];
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate all your database operations, including record creation, updates, or deletions, at the conclusion of the flow.",
+            docRefs: [
+                {
+                    label: "Flow Best Practices",
+                    path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
+                }
+            ],
+            isConfigurable: false,
+            label: "DML Statement In A Loop",
+            name: "DMLStatementInLoop",
+            supportedTypes: _internals.FlowType.backEndTypes
+        });
+    }
+};

package/main/rules/DuplicateDMLOperation.d.ts

@@ -0,0 +1,8 @@
+import { AdvancedRule } from "../models/AdvancedRule";
+import * as core from "../internals/internals";
+export declare class DuplicateDMLOperation extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+    private flagDML;
+    private findStart;
+}

package/main/rules/DuplicateDMLOperation.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DuplicateDMLOperation", {
+    enumerable: true,
+    get: function() {
+        return DuplicateDMLOperation;
+    }
+});
+const _AdvancedRule = require("../models/AdvancedRule");
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let DuplicateDMLOperation = class DuplicateDMLOperation extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        const processedElementIndexes = [];
+        const unconnectedElementIndexes = [];
+        const DuplicateDMLOperations = [];
+        const startingNode = this.findStart(flow);
+        if (!startingNode || startingNode === -1) {
+            throw "Can not find starting element";
+        }
+        let dmlFlag = false;
+        let indexesToProcess = [
+            startingNode
+        ];
+        do {
+            indexesToProcess = indexesToProcess.filter((index)=>!processedElementIndexes.includes(index));
+            if (indexesToProcess.length > 0) {
+                for (const [index, element] of flowElements.entries()){
+                    if (indexesToProcess.includes(index)) {
+                        const references = [];
+                        if (element.connectors && element.connectors.length > 0) {
+                            for (const connector of element.connectors){
+                                if (connector.reference) {
+                                    references.push(connector.reference);
+                                }
+                            }
+                        }
+                        dmlFlag = this.flagDML(element, dmlFlag);
+                        if (references.length > 0) {
+                            const elementsByReferences = flowElements.filter((element)=>references.includes(element.name));
+                            for (const nextElement of elementsByReferences){
+                                const nextIndex = flowElements.findIndex((element)=>nextElement.name === element.name);
+                                if ("screens" === nextElement.subtype) {
+                                    if (dmlFlag && nextElement.element["allowBack"] && nextElement.element["allowBack"] == "true" && nextElement.element["showFooter"] == "true") {
+                                        DuplicateDMLOperations.push(nextElement);
+                                    }
+                                }
+                                if (!processedElementIndexes.includes(nextIndex)) {
+                                    indexesToProcess.push(nextIndex);
+                                }
+                            }
+                        }
+                        processedElementIndexes.push(index);
+                    }
+                }
+            } else {
+                // skip unconnected elements
+                for (const index of flowElements.keys()){
+                    if (!processedElementIndexes.includes(index)) {
+                        unconnectedElementIndexes.push(index);
+                    }
+                }
+            }
+        }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
+        const results = [];
+        for (const det of DuplicateDMLOperations){
+            results.push(new _internals.ResultDetails(det));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    flagDML(element, dmlFlag) {
+        const dmlStatementTypes = [
+            "recordDeletes",
+            "recordUpdates",
+            "recordCreates"
+        ];
+        if (dmlStatementTypes.includes(element.subtype)) {
+            return true;
+        } else if (dmlFlag === true && element.subtype === "screens" && element.element["allowBack"] && element.element["allowBack"] == "true") {
+            return false;
+        } else {
+            return dmlFlag;
+        }
+    }
+    findStart(flow) {
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        let start;
+        if (flow.startElementReference) {
+            start = flowElements.findIndex((n)=>{
+                return n.name == flow.startElementReference;
+            });
+        } else {
+            start = flowElements.findIndex((n)=>{
+                return n.subtype === "start";
+            });
+        }
+        return start;
+    }
+    constructor(){
+        super({
+            name: "DuplicateDMLOperation",
+            label: "Duplicate DML Operation",
+            description: "When the flow executes database changes or actions between two screens, it's important to prevent users from navigating back between screens. Failure to do so may result in duplicate database operations being performed within the flow.",
+            supportedTypes: _internals.FlowType.visualTypes,
+            docRefs: [],
+            isConfigurable: false,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/FlowDescription.d.ts

@@ -0,0 +1,6 @@
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class FlowDescription extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}

package/main/rules/FlowDescription.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowDescription", {
+    enumerable: true,
+    get: function() {
+        return FlowDescription;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let FlowDescription = class FlowDescription extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        var _flow_xmldata;
+        const missingFlowDescription = !((_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : _flow_xmldata.description);
+        return missingFlowDescription ? new _internals.RuleResult(this, [
+            new _internals.ResultDetails(new _internals.FlowAttribute("undefined", "description", "!==null"))
+        ]) : new _internals.RuleResult(this, []);
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "Descriptions play a vital role in documentation. We highly recommend including details about where they are used and their intended purpose.",
+            docRefs: [],
+            isConfigurable: false,
+            label: "Missing Flow Description",
+            name: "FlowDescription",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes,
+                ..._internals.FlowType.visualTypes
+            ]
+        });
+    }
+};

package/main/rules/FlowName.d.ts

@@ -0,0 +1,7 @@
+import { AdvancedConfig } from "../interfaces/AdvancedRuleConfig";
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class FlowName extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow, advancedConfig?: AdvancedConfig): core.RuleResult;
+}

package/main/rules/FlowName.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowName", {
+    enumerable: true,
+    get: function() {
+        return FlowName;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let FlowName = class FlowName extends _AdvancedRule.AdvancedRule {
+    execute(flow, advancedConfig) {
+        const rawRegexp = advancedConfig && advancedConfig.expression ? advancedConfig.expression : "[A-Za-z0-9]+_[A-Za-z0-9]+";
+        const regexExp = rawRegexp;
+        const flowName = flow.name;
+        const conventionApplied = new RegExp(regexExp).test(flowName);
+        return !conventionApplied ? new _internals.RuleResult(this, [
+            new _internals.ResultDetails(new _internals.FlowAttribute(flowName, "name", regexExp))
+        ]) : new _internals.RuleResult(this, []);
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "The readability of a flow is of utmost importance. Establishing a naming convention for the Flow Name significantly enhances findability, searchability, and maintains overall consistency. It is advisable to include at least a domain and a brief description of the actions carried out in the flow, for instance, 'Service_OrderFulfillment'.",
+            docRefs: [
+                {
+                    label: "Naming your Flows is more critical than ever. By Stephen Church",
+                    path: "https://www.linkedin.com/posts/stephen-n-church_naming-your-flows-this-is-more-critical-activity-7099733198175158274-1sPx?utm_source=share&utm_medium=member_desktop"
+                }
+            ],
+            isConfigurable: true,
+            label: "Flow Naming Convention",
+            name: "FlowName",
+            supportedTypes: _internals.FlowType.allTypes()
+        });
+    }
+};

package/main/rules/GetRecordAllFields.d.ts

@@ -0,0 +1,6 @@
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class GetRecordAllFields extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}

package/main/rules/GetRecordAllFields.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GetRecordAllFields", {
+    enumerable: true,
+    get: function() {
+        return GetRecordAllFields;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let GetRecordAllFields = class GetRecordAllFields extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        var _flow_elements;
+        const results = [];
+        const getElementNodes = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((element)=>element.subtype === "recordLookups");
+        if (getElementNodes == null || getElementNodes.length === 0) {
+            return new _internals.RuleResult(this, results);
+        }
+        const errorNodes = getElementNodes.filter((element)=>{
+            const getRecordElement = element;
+            const hasQualifiedElementDefinition = typeof getRecordElement.element === "object";
+            if (!hasQualifiedElementDefinition) {
+                return false;
+            }
+            const concreteChildElement = getRecordElement.element;
+            const storeAllFields = "storeOutputAutomatically" in concreteChildElement && concreteChildElement["storeOutputAutomatically"];
+            const hasQueriedFields = "queriedFields" in concreteChildElement && concreteChildElement["queriedFields"].length > 0;
+            return storeAllFields && !hasQueriedFields;
+        }).map((element)=>{
+            const getRecordElement = element;
+            return new _internals.ResultDetails(getRecordElement);
+        });
+        results.push(...errorNodes);
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "Following the principle of least privilege (PoLP), avoid using Get Records with 'Automatically store all fields' unless necessary.",
+            docRefs: [
+                {
+                    label: "SOQL and SOSL | Best Practices for Deployments with Large Data Volumes",
+                    path: "https://developer.salesforce.com/docs/atlas.en-us.salesforce_large_data_volumes_bp.meta/salesforce_large_data_volumes_bp/ldv_deployments_best_practices_soql_and_sosl.htm"
+                },
+                {
+                    label: "Indexes | Best Practices",
+                    path: "https://developer.salesforce.com/docs/atlas.en-us.salesforce_large_data_volumes_bp.meta/salesforce_large_data_volumes_bp/ldv_deployments_infrastructure_indexes.htm"
+                }
+            ],
+            isConfigurable: false,
+            label: "Get Record All Fields",
+            name: "GetRecordAllFields",
+            supportedTypes: _internals.FlowType.allTypes()
+        }, {
+            severity: "warning"
+        });
+    }
+};

package/main/rules/HardcodedId.d.ts

@@ -0,0 +1,6 @@
+import { AdvancedRule } from "../models/AdvancedRule";
+import * as core from "../internals/internals";
+export declare class HardcodedId extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}