first commit

node_modules/n8n-workflow/dist/esm/workflow.d.ts

@@ -0,0 +1,155 @@
+import { Expression } from './expression';
+import type { IConnections, INode, INodeExecutionData, INodes, INodeType, INodeTypes, IPinData, IWorkflowSettings, IConnection, IConnectedNode, IDataObject, INodeConnection, NodeParameterValueType, NodeConnectionType } from './interfaces';
+export interface WorkflowParameters {
+    id?: string;
+    name?: string;
+    nodes: INode[];
+    connections: IConnections;
+    active: boolean;
+    nodeTypes: INodeTypes;
+    staticData?: IDataObject;
+    settings?: IWorkflowSettings;
+    pinData?: IPinData;
+}
+export declare class Workflow {
+    id: string;
+    name: string | undefined;
+    nodes: INodes;
+    connectionsBySourceNode: IConnections;
+    connectionsByDestinationNode: IConnections;
+    nodeTypes: INodeTypes;
+    expression: Expression;
+    active: boolean;
+    settings: IWorkflowSettings;
+    readonly timezone: string;
+    staticData: IDataObject;
+    testStaticData: IDataObject | undefined;
+    pinData?: IPinData;
+    constructor(parameters: WorkflowParameters);
+    setNodes(nodes: INode[]): void;
+    setConnections(connections: IConnections): void;
+    setPinData(pinData: IPinData | undefined): void;
+    setSettings(settings: IWorkflowSettings): void;
+    overrideStaticData(staticData?: IDataObject): void;
+    static getConnectionsByDestination(connections: IConnections): IConnections;
+    /**
+     * Returns the static data of the workflow.
+     * It gets saved with the workflow and will be the same for
+     * all workflow-executions.
+     *
+     * @param {string} type The type of data to return ("global"|"node")
+     * @param {INode} [node] If type is set to "node" then the node has to be provided
+     */
+    getStaticData(type: string, node?: INode): IDataObject;
+    setTestStaticData(testStaticData: IDataObject): void;
+    /**
+     * Returns all the trigger nodes in the workflow.
+     *
+     */
+    getTriggerNodes(): INode[];
+    /**
+     * Returns all the poll nodes in the workflow
+     *
+     */
+    getPollNodes(): INode[];
+    /**
+     * Returns all the nodes in the workflow for which the given
+     * checkFunction return true
+     *
+     * @param {(nodeType: INodeType) => boolean} checkFunction
+     */
+    queryNodes(checkFunction: (nodeType: INodeType) => boolean): INode[];
+    /**
+     * Returns the node with the given name if it exists else null
+     *
+     * @param {string} nodeName Name of the node to return
+     */
+    getNode(nodeName: string): INode | null;
+    /**
+     * Returns the nodes with the given names if they exist.
+     * If a node cannot be found it will be ignored, meaning the returned array
+     * of nodes can be smaller than the array of names.
+     */
+    getNodes(nodeNames: string[]): INode[];
+    /**
+     * Returns the pinData of the node with the given name if it exists
+     *
+     * @param {string} nodeName Name of the node to return the pinData of
+     */
+    getPinDataOfNode(nodeName: string): INodeExecutionData[] | undefined;
+    renameNodeInParameterValue(parameterValue: NodeParameterValueType, currentName: string, newName: string, { hasRenamableContent }?: {
+        hasRenamableContent: boolean;
+    }): NodeParameterValueType;
+    /**
+     * Rename a node in the workflow
+     *
+     * @param {string} currentName The current name of the node
+     * @param {string} newName The new name
+     */
+    renameNode(currentName: string, newName: string): void;
+    /**
+     * Finds the highest parent nodes of the node with the given name
+     *
+     * @param {NodeConnectionType} [type='main']
+     */
+    getHighestNode(nodeName: string, nodeConnectionIndex?: number, checkedNodes?: string[]): string[];
+    /**
+     * Returns all the after the given one
+     *
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getChildNodes(nodeName: string, type?: NodeConnectionType | 'ALL' | 'ALL_NON_MAIN', depth?: number): string[];
+    /**
+     * Returns all the nodes before the given one
+     *
+     * @param {NodeConnectionType} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getParentNodes(nodeName: string, type?: NodeConnectionType | 'ALL' | 'ALL_NON_MAIN', depth?: number): string[];
+    /**
+     * Gets all the nodes which are connected nodes starting from
+     * the given one
+     *
+     * @param {NodeConnectionType} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getConnectedNodes(connections: IConnections, nodeName: string, connectionType?: NodeConnectionType | 'ALL' | 'ALL_NON_MAIN', depth?: number, checkedNodesIncoming?: string[]): string[];
+    /**
+     * Returns all the nodes before the given one
+     *
+     * @param {*} [maxDepth=-1]
+     */
+    getParentNodesByDepth(nodeName: string, maxDepth?: number): IConnectedNode[];
+    /**
+     * Gets all the nodes which are connected nodes starting from
+     * the given one
+     * Uses BFS traversal
+     *
+     * @param {*} [maxDepth=-1]
+     */
+    searchNodesBFS(connections: IConnections, sourceNode: string, maxDepth?: number): IConnectedNode[];
+    getParentMainInputNode(node: INode): INode;
+    /**
+     * Returns via which output of the parent-node and index the current node
+     * they are connected
+     *
+     * @param {string} nodeName The node to check how it is connected with parent node
+     * @param {string} parentNodeName The parent node to get the output index of
+     * @param {string} [type='main']
+     */
+    getNodeConnectionIndexes(nodeName: string, parentNodeName: string, type?: NodeConnectionType): INodeConnection | undefined;
+    /**
+     * Returns from which of the given nodes the workflow should get started from
+     *
+     * @param {string[]} nodeNames The potential start nodes
+     */
+    __getStartNode(nodeNames: string[]): INode | undefined;
+    /**
+     * Returns the start node to start the workflow from
+     *
+     */
+    getStartNode(destinationNode?: string): INode | undefined;
+    getConnectionsBetweenNodes(sources: string[], targets: string[]): Array<[IConnection, IConnection]>;
+}
+//# sourceMappingURL=workflow.d.ts.map