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

package/main/models/FlowGraph.d.ts

@@ -0,0 +1,85 @@
+import { FlowNode } from "./FlowNode";
+/**
+ * FlowGraph: Pre-computed connectivity cache built using Compiler.
+ * Built once during Flow.preProcessNodes() to avoid repeated traversals.
+ *
+ * Uses the existing Compiler to build the graph - no duplicate logic!
+ */
+export declare class FlowGraph {
+    private nodeMap;
+    private reachableFromStart;
+    private elementsInLoop;
+    private faultConnectors;
+    private normalConnectors;
+    private allConnectors;
+    private reverseConnectors;
+    constructor(nodes: FlowNode[], startReference?: string, startNode?: FlowNode);
+    /**
+     * Add START node connectors to the connector maps (for flows with explicit <start> element)
+     */
+    private addStartNodeConnectors;
+    /**
+     * Add START edge for newer flows that use startElementReference (no explicit <start> node)
+     */
+    private addStartEdgeFromReference;
+    /**
+     * Build node map for O(1) lookups
+     */
+    private buildNodeMaps;
+    /**
+     * Build connector maps by inspecting node connectors
+     */
+    private buildConnectorMaps;
+    /**
+     * Use Compiler to compute which elements are reachable from start.
+     * This reuses the existing IDDFS traversal logic!
+     */
+    private computeReachability;
+    /**
+     * Use Compiler to compute which elements are inside loops.
+     * Calls Compiler.traverseFlow() for each loop with endElementName.
+     */
+    private computeLoopBoundaries;
+    isReachable(elementName: string): boolean;
+    getReachableElements(): Set<string>;
+    isInLoop(elementName: string): boolean;
+    getContainingLoop(elementName: string): string | undefined;
+    getLoopElements(loopName: string): Set<string>;
+    hasFaultConnector(elementName: string): boolean;
+    getFaultTargets(elementName: string): string[];
+    getNextElements(elementName: string): string[];
+    getAllNextElements(elementName: string): string[];
+    getPreviousElements(elementName: string): string[];
+    getNode(elementName: string): FlowNode | undefined;
+    isPartOfFaultHandling(elementName: string): boolean;
+    getLoopNodes(): FlowNode[];
+    forEachReachable(callback: (node: FlowNode) => void): void;
+    /**
+     * Export the graph to Mermaid flowchart syntax with rich documentation.
+     */
+    toMermaid(options?: {
+        includeDetails?: boolean;
+        includeMarkdownDocs?: boolean;
+        collapsedDetails?: boolean;
+        flowMetadata?: any;
+    }): string;
+    private generateMermaidDiagram;
+    private generateStartNode;
+    private getNodeShape;
+    private generateEdges;
+    private findEndNodes;
+    private generateLoopSubgraphs;
+    private generateMermaidStyles;
+    private generateNodeDetailsMarkdown;
+    private nodeToMarkdownTable;
+    private prettifyValue;
+    /**
+     * Generate full markdown documentation with diagram and node details
+     */
+    private generateFullMarkdownDoc;
+    /**
+     * Export the graph to PlantUML syntax for UML-style diagrams.
+     * @returns PlantUML string.
+     */
+    toPlantUML(): string;
+}

package/main/models/FlowGraph.js

@@ -0,0 +1,532 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowGraph", {
+    enumerable: true,
+    get: function() {
+        return FlowGraph;
+    }
+});
+const _Compiler = require("../libs/Compiler");
+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;
+}
+let FlowGraph = class FlowGraph {
+    /**
+   * Add START node connectors to the connector maps (for flows with explicit <start> element)
+   */ addStartNodeConnectors(startNode) {
+        const startName = 'START';
+        this.faultConnectors.set(startName, new Set());
+        this.normalConnectors.set(startName, new Set());
+        this.allConnectors.set(startName, new Set());
+        if (!startNode.connectors || startNode.connectors.length === 0) return;
+        for (const connector of startNode.connectors){
+            var _connector_connectorTargetReference, // START node typically has normal connectors, not fault connectors
+            _this_normalConnectors_get, _this_allConnectors_get, _this_reverseConnectors_get;
+            var _connector_connectorTargetReference_targetReference;
+            const targetRef = (_connector_connectorTargetReference_targetReference = (_connector_connectorTargetReference = connector.connectorTargetReference) === null || _connector_connectorTargetReference === void 0 ? void 0 : _connector_connectorTargetReference.targetReference) !== null && _connector_connectorTargetReference_targetReference !== void 0 ? _connector_connectorTargetReference_targetReference : connector.reference;
+            if (!targetRef) continue;
+            (_this_normalConnectors_get = this.normalConnectors.get(startName)) === null || _this_normalConnectors_get === void 0 ? void 0 : _this_normalConnectors_get.add(targetRef);
+            (_this_allConnectors_get = this.allConnectors.get(startName)) === null || _this_allConnectors_get === void 0 ? void 0 : _this_allConnectors_get.add(targetRef);
+            // Build reverse map
+            if (!this.reverseConnectors.has(targetRef)) {
+                this.reverseConnectors.set(targetRef, new Set());
+            }
+            (_this_reverseConnectors_get = this.reverseConnectors.get(targetRef)) === null || _this_reverseConnectors_get === void 0 ? void 0 : _this_reverseConnectors_get.add(startName);
+        }
+    }
+    /**
+   * Add START edge for newer flows that use startElementReference (no explicit <start> node)
+   */ addStartEdgeFromReference(startReference) {
+        var // Direct edge: START --> first element
+        _this_normalConnectors_get, _this_allConnectors_get, _this_reverseConnectors_get;
+        const startName = 'START';
+        this.faultConnectors.set(startName, new Set());
+        this.normalConnectors.set(startName, new Set());
+        this.allConnectors.set(startName, new Set());
+        (_this_normalConnectors_get = this.normalConnectors.get(startName)) === null || _this_normalConnectors_get === void 0 ? void 0 : _this_normalConnectors_get.add(startReference);
+        (_this_allConnectors_get = this.allConnectors.get(startName)) === null || _this_allConnectors_get === void 0 ? void 0 : _this_allConnectors_get.add(startReference);
+        // Build reverse map
+        if (!this.reverseConnectors.has(startReference)) {
+            this.reverseConnectors.set(startReference, new Set());
+        }
+        (_this_reverseConnectors_get = this.reverseConnectors.get(startReference)) === null || _this_reverseConnectors_get === void 0 ? void 0 : _this_reverseConnectors_get.add(startName);
+    }
+    /**
+   * Build node map for O(1) lookups
+   */ buildNodeMaps(nodes) {
+        for (const node of nodes){
+            this.nodeMap.set(node.name, node);
+        }
+    }
+    /**
+   * Build connector maps by inspecting node connectors
+   */ buildConnectorMaps(nodes) {
+        for (const node of nodes){
+            this.faultConnectors.set(node.name, new Set());
+            this.normalConnectors.set(node.name, new Set());
+            this.allConnectors.set(node.name, new Set());
+            if (!node.connectors || node.connectors.length === 0) continue;
+            for (const connector of node.connectors){
+                var _connector_connectorTargetReference, _this_allConnectors_get, _this_reverseConnectors_get;
+                var _connector_connectorTargetReference_targetReference;
+                const targetRef = (_connector_connectorTargetReference_targetReference = (_connector_connectorTargetReference = connector.connectorTargetReference) === null || _connector_connectorTargetReference === void 0 ? void 0 : _connector_connectorTargetReference.targetReference) !== null && _connector_connectorTargetReference_targetReference !== void 0 ? _connector_connectorTargetReference_targetReference : connector.reference;
+                if (!targetRef) continue;
+                // Categorize by connector type
+                if (connector.type === "faultConnector") {
+                    var _this_faultConnectors_get;
+                    (_this_faultConnectors_get = this.faultConnectors.get(node.name)) === null || _this_faultConnectors_get === void 0 ? void 0 : _this_faultConnectors_get.add(targetRef);
+                } else {
+                    var _this_normalConnectors_get;
+                    (_this_normalConnectors_get = this.normalConnectors.get(node.name)) === null || _this_normalConnectors_get === void 0 ? void 0 : _this_normalConnectors_get.add(targetRef);
+                }
+                (_this_allConnectors_get = this.allConnectors.get(node.name)) === null || _this_allConnectors_get === void 0 ? void 0 : _this_allConnectors_get.add(targetRef);
+                // Build reverse map for "previous elements" queries
+                if (!this.reverseConnectors.has(targetRef)) {
+                    this.reverseConnectors.set(targetRef, new Set());
+                }
+                (_this_reverseConnectors_get = this.reverseConnectors.get(targetRef)) === null || _this_reverseConnectors_get === void 0 ? void 0 : _this_reverseConnectors_get.add(node.name);
+            }
+        }
+    }
+    /**
+   * Use Compiler to compute which elements are reachable from start.
+   * This reuses the existing IDDFS traversal logic!
+   */ computeReachability(startReference) {
+        const compiler = new _Compiler.Compiler();
+        compiler.traverseFlow(startReference, (element)=>{
+            this.reachableFromStart.add(element.name);
+        }, this.nodeMap, this.allConnectors);
+    }
+    /**
+   * Use Compiler to compute which elements are inside loops.
+   * Calls Compiler.traverseFlow() for each loop with endElementName.
+   */ computeLoopBoundaries() {
+        const loopNodes = Array.from(this.nodeMap.values()).filter((n)=>n.subtype === "loops");
+        for (const loopNode of loopNodes){
+            var _loopNode_element_noMoreValuesConnector, _loopNode_element;
+            var _loopNode_element_noMoreValuesConnector_targetReference;
+            // Find loop end (noMoreValuesConnector)
+            const loopEnd = (_loopNode_element_noMoreValuesConnector_targetReference = (_loopNode_element = loopNode.element) === null || _loopNode_element === void 0 ? void 0 : (_loopNode_element_noMoreValuesConnector = _loopNode_element.noMoreValuesConnector) === null || _loopNode_element_noMoreValuesConnector === void 0 ? void 0 : _loopNode_element_noMoreValuesConnector.targetReference) !== null && _loopNode_element_noMoreValuesConnector_targetReference !== void 0 ? _loopNode_element_noMoreValuesConnector_targetReference : loopNode.name;
+            // Use Compiler to find all elements between loop start and end
+            const compiler = new _Compiler.Compiler();
+            compiler.traverseFlow(loopNode.name, (element)=>{
+                this.elementsInLoop.set(element.name, loopNode.name);
+            }, this.nodeMap, this.allConnectors, loopEnd); // Pass endElementName to stop at loop boundary
+        }
+    }
+    // ========== PUBLIC QUERY API ==========
+    isReachable(elementName) {
+        return this.reachableFromStart.has(elementName);
+    }
+    getReachableElements() {
+        return new Set(this.reachableFromStart);
+    }
+    isInLoop(elementName) {
+        return this.elementsInLoop.has(elementName);
+    }
+    getContainingLoop(elementName) {
+        return this.elementsInLoop.get(elementName);
+    }
+    getLoopElements(loopName) {
+        const result = new Set();
+        for (const [element, loop] of this.elementsInLoop){
+            if (loop === loopName) {
+                result.add(element);
+            }
+        }
+        return result;
+    }
+    hasFaultConnector(elementName) {
+        const faults = this.faultConnectors.get(elementName);
+        return faults ? faults.size > 0 : false;
+    }
+    getFaultTargets(elementName) {
+        return Array.from(this.faultConnectors.get(elementName) || []);
+    }
+    getNextElements(elementName) {
+        return Array.from(this.normalConnectors.get(elementName) || []);
+    }
+    getAllNextElements(elementName) {
+        return Array.from(this.allConnectors.get(elementName) || []);
+    }
+    getPreviousElements(elementName) {
+        return Array.from(this.reverseConnectors.get(elementName) || []);
+    }
+    getNode(elementName) {
+        return this.nodeMap.get(elementName);
+    }
+    isPartOfFaultHandling(elementName) {
+        const previous = this.getPreviousElements(elementName);
+        return previous.some((prev)=>{
+            const faultTargets = this.faultConnectors.get(prev);
+            var _faultTargets_has;
+            return (_faultTargets_has = faultTargets === null || faultTargets === void 0 ? void 0 : faultTargets.has(elementName)) !== null && _faultTargets_has !== void 0 ? _faultTargets_has : false;
+        });
+    }
+    getLoopNodes() {
+        return Array.from(this.nodeMap.values()).filter((n)=>n.subtype === "loops");
+    }
+    forEachReachable(callback) {
+        for (const elementName of this.reachableFromStart){
+            const node = this.nodeMap.get(elementName);
+            if (node) {
+                callback(node);
+            }
+        }
+    }
+    /**
+   * Export the graph to Mermaid flowchart syntax with rich documentation.
+   */ toMermaid(options = {}) {
+        let output = "";
+        const diagram = this.generateMermaidDiagram(options);
+        if (options.includeMarkdownDocs) {
+            output = this.generateFullMarkdownDoc(diagram, options);
+        } else {
+            output = `\`\`\`mermaid\n${diagram}\n\`\`\``;
+        }
+        return output;
+    }
+    generateMermaidDiagram(options) {
+        let mermaid = 'flowchart TB\n';
+        // START node with flow metadata
+        mermaid += this.generateStartNode(options.flowMetadata) + '\n\n';
+        // Define nodes using FlowNode helper methods
+        for (const [name, node] of this.nodeMap){
+            const icon = node.getIcon();
+            const typeLabel = node.getTypeLabel();
+            const summary = options.includeDetails ? node.getSummary() : '';
+            let label = `${icon} <em>${typeLabel}</em><br/>${node.label || node.name}`;
+            if (summary) {
+                label += `<br/><small>${summary}</small>`;
+            }
+            const shape = this.getNodeShape(node.subtype);
+            mermaid += `  ${name}${shape[0]}"${label}"${shape[1]}:::${node.subtype}\n`;
+        }
+        mermaid += '\n';
+        mermaid += this.generateEdges() + '\n';
+        mermaid += this.generateLoopSubgraphs() + '\n';
+        mermaid += this.generateMermaidStyles();
+        return mermaid;
+    }
+    generateStartNode(flowMetadata) {
+        if (!flowMetadata) {
+            return 'START(["\uD83D\uDE80 <b>START</b>"]):::startClass';
+        }
+        let label = '\uD83D\uDE80 <b>START</b>'; // ROCKET
+        if (flowMetadata.processType === 'Flow') {
+            label += '<br/><b>Screen Flow</b>';
+        } else if (flowMetadata.processType === 'AutoLaunchedFlow') {
+            label += '<br/><b>AutoLaunched Flow</b>';
+            if (flowMetadata.triggerType) {
+                label += `<br/>Type: <b>${this.prettifyValue(flowMetadata.triggerType)}</b>`;
+            }
+        } else if (flowMetadata.object) {
+            label += `<br/><b>${flowMetadata.object}</b>`;
+            if (flowMetadata.triggerType) {
+                label += `<br/>Type: <b>${this.prettifyValue(flowMetadata.triggerType)}</b>`;
+            }
+        }
+        if (flowMetadata.status) {
+            const statusIcon = flowMetadata.status === 'Active' ? '✅' : '⚠️';
+            label += `<br/>${statusIcon} ${flowMetadata.status}`;
+        }
+        return `START(["${label}"]):::startClass`;
+    }
+    getNodeShape(subtype) {
+        const shapeMap = {
+            decisions: [
+                '{',
+                '}'
+            ],
+            loops: [
+                '{{',
+                '}}'
+            ],
+            collectionProcessors: [
+                '{{',
+                '}}'
+            ],
+            transforms: [
+                '{{',
+                '}}'
+            ],
+            screens: [
+                '([',
+                '])'
+            ],
+            recordCreates: [
+                '[(',
+                ')]'
+            ],
+            recordDeletes: [
+                '[(',
+                ')]'
+            ],
+            recordLookups: [
+                '[(',
+                ')]'
+            ],
+            recordUpdates: [
+                '[(',
+                ')]'
+            ],
+            subflows: [
+                '[[',
+                ']]'
+            ],
+            assignments: [
+                '[\\',
+                '/]'
+            ],
+            default: [
+                '(',
+                ')'
+            ]
+        };
+        return shapeMap[subtype] || shapeMap.default;
+    }
+    generateEdges() {
+        let edges = '';
+        // Normal connectors
+        for (const [from, targets] of this.allConnectors){
+            for (const to of targets){
+                edges += `  ${from} --> ${to}\n`;
+            }
+        }
+        // Fault connectors (dashed)
+        for (const [from, faults] of this.faultConnectors){
+            for (const to of faults){
+                edges += `  ${from} -. Fault .-> ${to}\n`;
+            }
+        }
+        // Add END nodes
+        const endNodes = this.findEndNodes();
+        for (const endNode of endNodes){
+            edges += `  ${endNode}(( END )):::endClass\n`;
+        }
+        return edges;
+    }
+    findEndNodes() {
+        const endNodes = new Set();
+        for (const [from, targets] of this.allConnectors){
+            for (const to of targets){
+                // If target doesn't exist in nodeMap, it's an END
+                if (!this.nodeMap.has(to)) {
+                    endNodes.add(to);
+                }
+            }
+        }
+        return endNodes;
+    }
+    generateLoopSubgraphs() {
+        let subgraphs = '';
+        for (const loopNode of this.getLoopNodes()){
+            const loopElems = this.getLoopElements(loopNode.name);
+            if (loopElems.size > 0) {
+                subgraphs += `  subgraph "${loopNode.label || loopNode.name} Loop"\n`;
+                for (const elem of loopElems){
+                    subgraphs += `    ${elem}\n`;
+                }
+                subgraphs += '  end\n';
+            }
+        }
+        return subgraphs;
+    }
+    generateMermaidStyles() {
+        const styles = {
+            actionCalls: {
+                fill: '#D4E4FC',
+                color: 'black'
+            },
+            assignments: {
+                fill: '#FBEED7',
+                color: 'black'
+            },
+            collectionProcessors: {
+                fill: '#F0E3FA',
+                color: 'black'
+            },
+            customErrors: {
+                fill: '#FFE9E9',
+                color: 'black'
+            },
+            decisions: {
+                fill: '#FDEAF6',
+                color: 'black'
+            },
+            loops: {
+                fill: '#FDEAF6',
+                color: 'black'
+            },
+            recordCreates: {
+                fill: '#FFF8C9',
+                color: 'black'
+            },
+            recordDeletes: {
+                fill: '#FFF8C9',
+                color: 'black'
+            },
+            recordLookups: {
+                fill: '#EDEAFF',
+                color: 'black'
+            },
+            recordUpdates: {
+                fill: '#FFF8C9',
+                color: 'black'
+            },
+            screens: {
+                fill: '#DFF6FF',
+                color: 'black'
+            },
+            subflows: {
+                fill: '#D4E4FC',
+                color: 'black'
+            },
+            transforms: {
+                fill: '#FDEAF6',
+                color: 'black'
+            },
+            startClass: {
+                fill: '#D9F2E6',
+                color: 'black'
+            },
+            endClass: {
+                fill: '#F9BABA',
+                color: 'black'
+            }
+        };
+        let styleStr = '';
+        for (const [className, style] of Object.entries(styles)){
+            styleStr += `  classDef ${className} fill:${style.fill},color:${style.color},stroke:#333,stroke-width:2px\n`;
+        }
+        return styleStr;
+    }
+    generateNodeDetailsMarkdown(collapsed) {
+        let md = '## Flow Nodes Details\n\n';
+        if (collapsed) {
+            md += '<details><summary>NODE DETAILS (expand to view)</summary>\n\n';
+        }
+        for (const [name, node] of this.nodeMap){
+            md += `### ${name}\n\n`;
+            md += this.nodeToMarkdownTable(node);
+            md += '\n';
+        }
+        if (collapsed) {
+            md += '</details>\n\n';
+        }
+        return md;
+    }
+    nodeToMarkdownTable(node) {
+        let table = '| Property | Value |\n|:---|:---|\n';
+        // Use typed properties from FlowNode
+        if (node.label) table += `| Label | ${node.label} |\n`;
+        table += `| Type | ${node.getTypeLabel()} |\n`;
+        // Type-specific properties (now type-safe!)
+        if (node.actionType) table += `| Action Type | ${this.prettifyValue(node.actionType)} |\n`;
+        if (node.actionName) table += `| Action Name | ${node.actionName} |\n`;
+        if (node.object) table += `| Object | ${node.object} |\n`;
+        if (node.flowName) table += `| Subflow | ${node.flowName} |\n`;
+        if (node.collectionReference) table += `| Collection | ${node.collectionReference} |\n`;
+        if (node.elementSubtype) table += `| Subtype | ${this.prettifyValue(node.elementSubtype)} |\n`;
+        // Decision rules
+        if (node.rules && node.rules.length > 0) {
+            table += `| Rules | ${node.rules.length} |\n`;
+            for (const rule of node.rules){
+                const conditions = Array.isArray(rule.conditions) ? rule.conditions : rule.conditions ? [
+                    rule.conditions
+                ] : [];
+                table += `| ↳ ${rule.label || rule.name} | ${conditions.length} condition(s) |\n`;
+            }
+        }
+        // Screen fields
+        if (node.fields && node.fields.length > 0) {
+            table += `| Fields | ${node.fields.length} |\n`;
+        }
+        if (node.description) table += `| Description | ${node.description} |\n`;
+        if (node.faultConnector) table += `| Has Fault Handler | ✅ |\n`;
+        return table;
+    }
+    prettifyValue(value) {
+        return value.replace(/([A-Z])/g, ' $1').replace(/^./, (str)=>str.toUpperCase()).trim();
+    }
+    /**
+   * Generate full markdown documentation with diagram and node details
+   */ generateFullMarkdownDoc(diagram, options) {
+        let md = '';
+        // Header with flow metadata would come from Flow class
+        md += '## Flow Diagram\n\n';
+        md += '```mermaid\n';
+        md += diagram;
+        md += '\n```\n\n';
+        // Node details section
+        if (options.includeDetails) {
+            md += this.generateNodeDetailsMarkdown(options.collapsedDetails);
+        }
+        return md;
+    }
+    /**
+   * Export the graph to PlantUML syntax for UML-style diagrams.
+   * @returns PlantUML string.
+   */ toPlantUML() {
+        let plantuml = '@startuml\nskinparam activityBackgroundColor #D4E4FC\n'; // Basic styling
+        // Nodes
+        for (const [name, node] of this.nodeMap){
+            plantuml += `activity "${node.subtype}: ${name}" as ${name}\n`;
+        }
+        // Edges
+        for (const [from, targets] of this.allConnectors){
+            for (const to of targets){
+                plantuml += `${from} --> ${to}\n`;
+            }
+        }
+        // Loops as groups
+        for (const loopNode of this.getLoopNodes()){
+            plantuml += `partition "${loopNode.name} Loop" {\n`;
+            const loopElems = this.getLoopElements(loopNode.name);
+            for (const elem of loopElems){
+                plantuml += `  ${elem}\n`;
+            }
+            plantuml += '}\n';
+        }
+        plantuml += '@enduml';
+        return plantuml;
+    }
+    constructor(nodes, startReference, startNode){
+        // Fast lookups by element name
+        _define_property(this, "nodeMap", new Map());
+        // Pre-computed sets for common queries (built using Compiler)
+        _define_property(this, "reachableFromStart", new Set());
+        _define_property(this, "elementsInLoop", new Map()); // element -> loop name
+        // Connector metadata (extracted during node processing)
+        _define_property(this, "faultConnectors", new Map());
+        _define_property(this, "normalConnectors", new Map());
+        _define_property(this, "allConnectors", new Map());
+        _define_property(this, "reverseConnectors", new Map());
+        this.buildNodeMaps(nodes);
+        this.buildConnectorMaps(nodes);
+        // ALWAYS ensure START node edges exist
+        if (startNode) {
+            // Old flows: use explicit <start> element connectors
+            this.addStartNodeConnectors(startNode);
+        } else if (startReference) {
+            // New flows: direct edge from START to startElementReference
+            this.addStartEdgeFromReference(startReference);
+        }
+        this.computeLoopBoundaries();
+        if (startReference) {
+            this.computeReachability(startReference);
+        }
+    }
+};

package/main/models/FlowNode.d.ts

@@ -1,9 +1,65 @@
 import { FlowElement } from "./FlowElement";
 import { FlowElementConnector } from "./FlowElementConnector";
+import { type NodeIconConfig } from "../config/NodeIcons";
 export declare class FlowNode extends FlowElement {
     connectors: FlowElementConnector[];
-    locationX: string;
-    locationY: string;
+    locationX?: string;
+    locationY?: string;
+    label?: string;
+    description?: string;
+    actionType?: string;
+    actionName?: string;
+    object?: string;
+    inputReference?: string;
+    outputReference?: string;
+    elementSubtype?: string;
+    collectionReference?: string;
+    flowName?: string;
+    rules?: any[];
+    defaultConnectorLabel?: string;
+    iterationOrder?: string;
+    fields?: any[];
+    allowPause?: boolean;
+    showFooter?: boolean;
+    faultConnector?: FlowElementConnector;
+    private static iconConfig;
+    /**
+     * 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: NodeIconConfig): void;
+    /**
+     * Use ASCII icons instead of emoji (for older browsers/terminals)
+     */
+    static useAsciiIcons(): void;
+    /**
+     * Reset to default emoji icons
+     */
+    static useDefaultIcons(): void;
     constructor(provName: string, subtype: string, element: object);
+    private extractTypeSpecificProperties;
+    /**
+     * Get a human-readable summary of this node
+     */
+    getSummary(): string;
+    /**
+     * Get the icon for this node type
+     */
+    getIcon(): string;
+    /**
+     * Get the display name for this node type
+     */
+    getTypeLabel(): string;
+    private prettifyValue;
     private getConnectors;
 }