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

package/main/libs/Scan2.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "scan2", {
+    enumerable: true,
+    get: function() {
+        return scan2;
+    }
+});
+const _internals = require("../internals/internals");
+const _DefaultRuleStore = require("../store/DefaultRuleStore");
+const _DynamicRule = require("./DynamicRule");
+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 _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function scan2(parsedFlows, ruleOptions) {
+    const flows = parsedFlows.map((parsedFlow)=>parsedFlow.flow);
+    const scanResults = [];
+    for (const flow of flows){
+        scanResults.push(scanFlowWithConfig(flow, ruleOptions));
+    }
+    return scanResults;
+}
+function ruleAndConfig(ruleOptions) {
+    // for unit tests, use a small set of rules
+    const ruleConfiguration = unifiedRuleConfig(ruleOptions);
+    let allRules = _object_spread({}, _DefaultRuleStore.DefaultRuleStore, _DefaultRuleStore.BetaRuleStore);
+    if (// overrideConfig === "true" &&
+    (ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules) && Object.keys(ruleOptions.rules).length > 0) {
+        allRules = Object.entries(allRules).reduce((accumulator, [ruleName, rule])=>{
+            var _ruleOptions_rules;
+            if (ruleOptions === null || ruleOptions === void 0 ? void 0 : (_ruleOptions_rules = ruleOptions.rules) === null || _ruleOptions_rules === void 0 ? void 0 : _ruleOptions_rules[ruleName]) {
+                accumulator[ruleName] = rule;
+            }
+            return accumulator;
+        }, {});
+    }
+    return [
+        allRules,
+        ruleConfiguration
+    ];
+}
+function scanFlowWithConfig(flow, ruleOptions) {
+    const [allRules, ruleConfiguration] = ruleAndConfig(ruleOptions);
+    const ruleResults = [];
+    for (const [ruleName] of Object.entries(allRules)){
+        var _ruleConfiguration_ruleName, _ruleConfiguration_ruleName1, _ruleOptions_exceptions_flowName, _ruleOptions_exceptions;
+        const rule = new _DynamicRule.DynamicRule(ruleName);
+        if (!rule.supportedTypes.includes(flow.type) || (ruleConfiguration === null || ruleConfiguration === void 0 ? void 0 : (_ruleConfiguration_ruleName = ruleConfiguration[ruleName]) === null || _ruleConfiguration_ruleName === void 0 ? void 0 : _ruleConfiguration_ruleName.disabled) === true) {
+            ruleResults.push(new _internals.RuleResult(rule, []));
+            continue;
+        }
+        if (ruleConfiguration === null || ruleConfiguration === void 0 ? void 0 : (_ruleConfiguration_ruleName1 = ruleConfiguration[ruleName]) === null || _ruleConfiguration_ruleName1 === void 0 ? void 0 : _ruleConfiguration_ruleName1.severity) {
+            rule.severity = ruleConfiguration[ruleName].severity;
+        }
+        const flowName = flow.name;
+        var _ruleConfiguration_ruleName2;
+        const userRuleConfiguration = (_ruleConfiguration_ruleName2 = ruleConfiguration[ruleName]) !== null && _ruleConfiguration_ruleName2 !== void 0 ? _ruleConfiguration_ruleName2 : {};
+        var _ruleOptions_exceptions_flowName_ruleName;
+        const userFlowSuppressions = (_ruleOptions_exceptions_flowName_ruleName = ruleOptions === null || ruleOptions === void 0 ? void 0 : (_ruleOptions_exceptions = ruleOptions.exceptions) === null || _ruleOptions_exceptions === void 0 ? void 0 : (_ruleOptions_exceptions_flowName = _ruleOptions_exceptions[flowName]) === null || _ruleOptions_exceptions_flowName === void 0 ? void 0 : _ruleOptions_exceptions_flowName[ruleName]) !== null && _ruleOptions_exceptions_flowName_ruleName !== void 0 ? _ruleOptions_exceptions_flowName_ruleName : [];
+        ruleResults.push(rule.execute2(flow, userRuleConfiguration, userFlowSuppressions));
+    }
+    return new _internals.ScanResult(flow, ruleResults);
+}
+function unifiedRuleConfig(ruleOptions) {
+    var _ruleOptions_rules;
+    const configuredRules = (_ruleOptions_rules = ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules) !== null && _ruleOptions_rules !== void 0 ? _ruleOptions_rules : {};
+    const activeConfiguredRules = Object.entries(configuredRules).reduce((accumulator, [ruleName, config])=>{
+        return _object_spread_props(_object_spread({}, accumulator), {
+            [ruleName]: config
+        });
+    }, {});
+    return activeConfiguredRules;
+}

package/main/libs/ScanFlows.d.ts

@@ -0,0 +1,4 @@
+import { Flow, IRulesConfig, ScanResult } from "../../main/internals/internals";
+import { ParsedFlow } from "../models/ParsedFlow";
+export declare function scan(parsedFlows: ParsedFlow[], ruleOptions?: IRulesConfig): ScanResult[];
+export declare function ScanFlows(flows: Flow[], ruleOptions?: IRulesConfig): ScanResult[];

package/main/libs/ScanFlows.js

@@ -0,0 +1,103 @@
+"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 ScanFlows () {
+        return ScanFlows;
+    },
+    get scan () {
+        return scan;
+    }
+});
+const _internals = require("../../main/internals/internals");
+const _GetRuleDefinitions = require("./GetRuleDefinitions");
+const _Scan2 = require("./Scan2");
+const { IS_NEW_SCAN_ENABLED: isNewScanEnabled, OVERRIDE_CONFIG: overrideConfig } = process.env;
+function scan(parsedFlows, ruleOptions) {
+    // TD see jest.env-setup.ts for testing scan2
+    if (isNewScanEnabled === "true" && overrideConfig !== null && overrideConfig !== undefined) {
+        return (0, _Scan2.scan2)(parsedFlows, ruleOptions);
+    }
+    const flows = [];
+    for (const flow of parsedFlows){
+        if (!flow.errorMessage && flow.flow) {
+            flows.push(flow.flow);
+        }
+    }
+    let scanResults;
+    if ((ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules) && Object.entries(ruleOptions.rules).length > 0) {
+        scanResults = ScanFlows(flows, ruleOptions);
+    } else {
+        scanResults = ScanFlows(flows);
+    }
+    generalSuppressions(scanResults, ruleOptions);
+    return scanResults;
+}
+function ScanFlows(flows, ruleOptions) {
+    const flowResults = [];
+    let selectedRules = [];
+    if (ruleOptions && ruleOptions.rules) {
+        const ruleMap = new Map();
+        for (const [ruleName, rule] of Object.entries(ruleOptions.rules)){
+            ruleMap.set(ruleName, rule);
+        }
+        selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)(ruleMap);
+    } else {
+        selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)();
+    }
+    for (const flow of flows){
+        const ruleResults = [];
+        for (const rule of selectedRules){
+            try {
+                if (rule.supportedTypes.includes(flow.type)) {
+                    let config = undefined;
+                    if (ruleOptions && ruleOptions["rules"] && ruleOptions["rules"][rule.name]) {
+                        config = ruleOptions["rules"][rule.name];
+                    }
+                    const result = config && Object.keys(config).length > 0 ? rule.execute(flow, config) : rule.execute(flow);
+                    if (result.severity !== rule.severity) {
+                        result.severity = rule.severity;
+                    }
+                    ruleResults.push(result);
+                } else {
+                    ruleResults.push(new _internals.RuleResult(rule, []));
+                }
+            } catch (error) {
+                const message = `Something went wrong while executing ${rule.name} in the Flow: ${flow.name} with error ${error}`;
+                ruleResults.push(new _internals.RuleResult(rule, [], message));
+            }
+        }
+        flowResults.push(new _internals.ScanResult(flow, ruleResults));
+    }
+    return flowResults;
+}
+function generalSuppressions(scanResults, ruleOptions) {
+    if (!(ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.exceptions)) {
+        return;
+    }
+    const applyExceptionToResults = (ruleResult, exceptions)=>{
+        const filteredDetails = ruleResult.details.filter((detail)=>!exceptions.includes(detail.name));
+        ruleResult.details = filteredDetails;
+        ruleResult.occurs = filteredDetails.length > 0;
+    };
+    for (const [flowName, exceptionElements] of Object.entries(ruleOptions.exceptions)){
+        const matchingScanResult = scanResults.find((result)=>result.flow.name === flowName);
+        if (!matchingScanResult) {
+            continue;
+        }
+        for (const ruleResult of matchingScanResult.ruleResults){
+            const exceptions = exceptionElements[ruleResult.ruleName];
+            if (!exceptions) {
+                continue;
+            }
+            applyExceptionToResults(ruleResult, exceptions);
+        }
+    }
+}

package/main/models/AdvancedRule.d.ts

@@ -0,0 +1,44 @@
+import { AdvancedConfig } from "../interfaces/AdvancedRuleConfig";
+import { AdvancedRuleDefinition } from "../interfaces/AdvancedRuleDefintion";
+import { IRuleDefinition } from "../internals/internals";
+import { Flow } from "./Flow";
+import { RuleCommon } from "./RuleCommon";
+import { RuleInfo } from "./RuleInfo";
+import { RuleResult } from "./RuleResult";
+/**
+ * Abstract base class for advanced rules, extending {@link RuleCommon} and implementing
+ * {@link AdvancedRuleDefinition} and {@link IRuleDefinition}.
+ *
+ * @remarks
+ * This class provides a structure for advanced rule implementations, including
+ * support for advanced suppression and user-defined suppressions.
+ *
+ * @param info - The rule metadata information.
+ * @param optional - Optional configuration, such as severity.
+ */
+export declare abstract class AdvancedRule extends RuleCommon implements AdvancedRuleDefinition, IRuleDefinition {
+    /**
+     * Constructs an instance of {@link AdvancedRule}.
+     *
+     * @param info - The rule metadata information.
+     * @param optional - Optional configuration, such as severity.
+     */
+    constructor(info: RuleInfo, optional?: {
+        severity?: string;
+    });
+    /**
+     * Your rule
+     * @param flow - The flow to analyze.
+     * @param ruleOptions - Optional rule-specific options.
+     */
+    abstract execute(flow: Flow, ruleOptions?: object): RuleResult;
+    /**
+     * Executes the rule with advanced configuration and applies suppressions.
+     *
+     * @param flow - The flow to analyze.
+     * @param ruleConfiguration - Optional advanced rule configuration.
+     * @param userFlowSuppressions - Optional list of user-defined suppressions.
+     * @returns The result of rule execution after applying suppressions.
+     */
+    execute2(flow: Flow, ruleConfiguration?: AdvancedConfig, userFlowSuppressions?: string[]): RuleResult;
+}

package/main/models/AdvancedRule.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AdvancedRule", {
+    enumerable: true,
+    get: function() {
+        return AdvancedRule;
+    }
+});
+const _util = require("util");
+const _RuleCommon = require("./RuleCommon");
+const _RuleResult = require("./RuleResult");
+let AdvancedRule = class AdvancedRule extends _RuleCommon.RuleCommon {
+    /**
+   * Executes the rule with advanced configuration and applies suppressions.
+   *
+   * @param flow - The flow to analyze.
+   * @param ruleConfiguration - Optional advanced rule configuration.
+   * @param userFlowSuppressions - Optional list of user-defined suppressions.
+   * @returns The result of rule execution after applying suppressions.
+   */ execute2(flow, ruleConfiguration, userFlowSuppressions) {
+        if (!hasClassicRuleDefinition(this)) {
+            return new _RuleResult.RuleResult(this, []);
+        }
+        let ruleResult;
+        try {
+            ruleResult = this.execute(flow, ruleConfiguration);
+        } catch (error) {
+            return new _RuleResult.RuleResult(this, [], (0, _util.inspect)(error));
+        }
+        if (hasAdvancedSuppression(this)) {
+            ruleResult = this.suppress(ruleResult, ruleConfiguration);
+        }
+        ruleResult = generalSuppressions(ruleResult, userFlowSuppressions);
+        return ruleResult;
+    }
+    /**
+   * Constructs an instance of {@link AdvancedRule}.
+   *
+   * @param info - The rule metadata information.
+   * @param optional - Optional configuration, such as severity.
+   */ constructor(info, optional){
+        super(info, optional);
+    }
+};
+/**
+ * Applies user-defined suppressions to the rule result.
+ *
+ * @param ruleResult - The result of rule execution.
+ * @param userFlowRuleSuppressions - Optional list of suppression names to filter out.
+ * @returns The filtered rule result.
+ */ function generalSuppressions(ruleResult, userFlowRuleSuppressions) {
+    if (!userFlowRuleSuppressions || userFlowRuleSuppressions.length === 0) {
+        return ruleResult;
+    }
+    const filteredDetails = ruleResult.details.filter((detail)=>!userFlowRuleSuppressions.includes(detail.name));
+    ruleResult.details = filteredDetails;
+    ruleResult.occurs = filteredDetails.length > 0;
+    return ruleResult;
+}
+/**
+ * Type guard to check if a value is a function.
+ *
+ * @param val - The value to check.
+ * @returns True if the value is a function, false otherwise.
+ */ // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+const isFunction = (val)=>typeof val === "function";
+/**
+ * Type guard to check if an instance implements {@link AdvancedSuppression}.
+ *
+ * @param instance - The instance to check.
+ * @returns True if the instance has a suppress method, false otherwise.
+ */ function hasAdvancedSuppression(instance) {
+    return isFunction(instance.suppress);
+}
+/**
+ * Type guard to check if an instance implements {@link IRuleDefinition}.
+ *
+ * @param instance - The instance to check.
+ * @returns True if the instance has an execute method, false otherwise.
+ */ function hasClassicRuleDefinition(instance) {
+    return isFunction(instance.execute);
+}

package/main/models/Flow.d.ts

@@ -0,0 +1,33 @@
+import { FlowElement } from "./FlowElement";
+export declare class Flow {
+    /**
+     * Categorized flow contents that should be used in the rule implementation
+     */
+    elements?: FlowElement[];
+    fsPath: any;
+    interviewLabel?: string;
+    label: string;
+    name?: string;
+    processMetadataValues?: any;
+    processType?: any;
+    root?: any;
+    start?: any;
+    startElementReference?: any;
+    startReference: any;
+    status?: any;
+    triggerOrder?: number;
+    type?: any;
+    /**
+     * XML to JSON conversion in raw format
+     */
+    xmldata: any;
+    private flowMetadata;
+    private flowNodes;
+    private flowResources;
+    private flowVariables;
+    constructor(path?: string, data?: unknown);
+    preProcessNodes(): void;
+    toXMLString(): string;
+    private findStart;
+    private generateDoc;
+}

package/main/models/Flow.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Flow", {
+    enumerable: true,
+    get: function() {
+        return Flow;
+    }
+});
+const _fastxmlparser = require("fast-xml-parser");
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _FlowMetadata = require("./FlowMetadata");
+const _FlowNode = require("./FlowNode");
+const _FlowResource = require("./FlowResource");
+const _FlowVariable = require("./FlowVariable");
+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;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+let Flow = class Flow {
+    preProcessNodes() {
+        this.label = this.xmldata.label;
+        this.interviewLabel = this.xmldata.interviewLabel;
+        this.processType = this.xmldata.processType;
+        this.processMetadataValues = this.xmldata.processMetadataValues;
+        this.startElementReference = this.xmldata.startElementReference;
+        this.start = this.xmldata.start;
+        this.status = this.xmldata.status;
+        this.type = this.xmldata.processType;
+        this.triggerOrder = this.xmldata.triggerOrder;
+        const allNodes = [];
+        for(const nodeType in this.xmldata){
+            // Skip xmlns and attributes (updated: generalized from your commented line)
+            if (nodeType.startsWith("@_") || nodeType === "@xmlns") {
+                continue;
+            }
+            const data = this.xmldata[nodeType];
+            if (this.flowMetadata.includes(nodeType)) {
+                if (Array.isArray(data)) {
+                    for (const node of data){
+                        allNodes.push(new _FlowMetadata.FlowMetadata(nodeType, node));
+                    }
+                } else {
+                    allNodes.push(new _FlowMetadata.FlowMetadata(nodeType, data));
+                }
+            } else if (this.flowVariables.includes(nodeType)) {
+                if (Array.isArray(data)) {
+                    for (const node of data){
+                        allNodes.push(new _FlowVariable.FlowVariable(node.name, nodeType, node));
+                    }
+                } else {
+                    allNodes.push(new _FlowVariable.FlowVariable(data.name, nodeType, data));
+                }
+            } else if (this.flowNodes.includes(nodeType)) {
+                if (Array.isArray(data)) {
+                    for (const node of data){
+                        allNodes.push(new _FlowNode.FlowNode(node.name, nodeType, node));
+                    }
+                } else {
+                    allNodes.push(new _FlowNode.FlowNode(data.name, nodeType, data));
+                }
+            } else if (this.flowResources.includes(nodeType)) {
+                if (Array.isArray(data)) {
+                    for (const node of data){
+                        allNodes.push(new _FlowResource.FlowResource(node.name, nodeType, node));
+                    }
+                } else {
+                    allNodes.push(new _FlowResource.FlowResource(data.name, nodeType, data));
+                }
+            }
+        }
+        this.elements = allNodes;
+        this.startReference = this.findStart();
+    }
+    toXMLString() {
+        try {
+            return this.generateDoc();
+        } catch (exception) {
+            console.warn(`Unable to write xml, caught an error ${exception.toString()}`);
+            return "";
+        }
+    }
+    findStart() {
+        let start = "";
+        const flowElements = this.elements.filter((node)=>node instanceof _FlowNode.FlowNode);
+        if (this.startElementReference) {
+            start = this.startElementReference;
+        } else if (flowElements.find((n)=>{
+            return n.subtype === "start";
+        })) {
+            const startElement = flowElements.find((n)=>{
+                return n.subtype === "start";
+            });
+            start = startElement.connectors[0]["reference"];
+        }
+        return start;
+    }
+    generateDoc() {
+        // eslint-disable-next-line sonarjs/no-clear-text-protocols
+        const flowXmlNamespace = "http://soap.sforce.com/2006/04/metadata";
+        const builderOptions = {
+            format: true,
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            suppressEmptyNode: false,
+            suppressBooleanAttributes: false // NEW: Force ="true" for boolean-like strings (fixes missing value)
+        };
+        const builder = new _fastxmlparser.XMLBuilder(builderOptions);
+        // Fallback: Inject xmlns as attribute if missing
+        const xmldataWithNs = _object_spread({}, this.xmldata);
+        if (!xmldataWithNs["@_xmlns"]) {
+            xmldataWithNs["@_xmlns"] = flowXmlNamespace;
+        }
+        // Optional: Add xsi if needed (often in parsed data; test has it in root)
+        if (!xmldataWithNs["@_xmlns:xsi"]) {
+            xmldataWithNs["@_xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance";
+        }
+        // Build: Wrap in { Flow: ... }
+        const rootObj = {
+            Flow: xmldataWithNs
+        };
+        return builder.build(rootObj);
+    }
+    constructor(path, data){
+        /**
+   * Categorized flow contents that should be used in the rule implementation
+   */ _define_property(this, "elements", void 0);
+        _define_property(this, "fsPath", void 0);
+        _define_property(this, "interviewLabel", void 0);
+        _define_property(this, "label", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "processMetadataValues", void 0);
+        _define_property(this, "processType", void 0);
+        _define_property(this, "root", void 0);
+        _define_property(this, "start", void 0);
+        _define_property(this, "startElementReference", void 0);
+        _define_property(this, "startReference", void 0);
+        _define_property(this, "status", void 0);
+        _define_property(this, "triggerOrder", void 0);
+        _define_property(this, "type", void 0);
+        /**
+   * XML to JSON conversion in raw format
+   */ _define_property(this, "xmldata", void 0);
+        _define_property(this, "flowMetadata", [
+            "description",
+            "apiVersion",
+            "processMetadataValues",
+            "processType",
+            "interviewLabel",
+            "label",
+            "status",
+            "runInMode",
+            "startElementReference",
+            "isTemplate",
+            "fullName",
+            "timeZoneSidKey",
+            "isAdditionalPermissionRequiredToRun",
+            "migratedFromWorkflowRuleName",
+            "triggerOrder",
+            "environments",
+            "segment"
+        ]);
+        _define_property(this, "flowNodes", [
+            "actionCalls",
+            "apexPluginCalls",
+            "assignments",
+            "collectionProcessors",
+            "decisions",
+            "loops",
+            "orchestratedStages",
+            "recordCreates",
+            "recordDeletes",
+            "recordLookups",
+            "recordUpdates",
+            "recordRollbacks",
+            "screens",
+            "start",
+            "steps",
+            "subflows",
+            "waits",
+            "transforms",
+            "customErrors"
+        ]);
+        _define_property(this, "flowResources", [
+            "textTemplates",
+            "stages"
+        ]);
+        _define_property(this, "flowVariables", [
+            "choices",
+            "constants",
+            "dynamicChoiceSets",
+            "formulas",
+            "variables"
+        ]);
+        if (path) {
+            this.fsPath = _path.resolve(path);
+            let flowName = _path.basename(_path.basename(this.fsPath), _path.extname(this.fsPath));
+            if (flowName.includes(".")) {
+                flowName = flowName.split(".")[0];
+            }
+            this.name = flowName;
+        }
+        if (data) {
+            const hasFlowElement = typeof data === "object" && "Flow" in data;
+            if (hasFlowElement) {
+                this.xmldata = data.Flow;
+            } else this.xmldata = data;
+            this.preProcessNodes();
+        }
+    }
+};

package/main/models/FlowAttribute.d.ts

@@ -0,0 +1,7 @@
+export declare class FlowAttribute {
+    name: string;
+    subtype: string;
+    expression?: string;
+    metaType: string;
+    constructor(name: string, subtype: string, expression?: string);
+}