@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/Interfaces.d.ts

@@ -0,0 +1,147 @@
+import type { IAdditionalCredentialOptions, IAllExecuteFunctions, IBinaryData, ICredentialTestFunctions as ICredentialTestFunctionsBase, ICredentialType, IDataObject, IExecuteFunctions as IExecuteFunctionsBase, IExecuteSingleFunctions as IExecuteSingleFunctionsBase, IHookFunctions as IHookFunctionsBase, IHttpRequestOptions, ILoadOptionsFunctions as ILoadOptionsFunctionsBase, IN8nHttpFullResponse, IN8nHttpResponse, INodeExecutionData, INodeType, IOAuth2Options, IPollFunctions as IPollFunctionsBase, IPollResponse, ITriggerFunctions as ITriggerFunctionsBase, ITriggerResponse, IWebhookFunctions as IWebhookFunctionsBase, IWorkflowSettings as IWorkflowSettingsWorkflow } from "@fsai-flow/workflow";
+import type { OptionsWithUri, OptionsWithUrl, RequestPromiseOptions } from "./RequestTypes";
+interface Constructable<T> {
+    new (): T;
+}
+export interface IProcessMessage {
+    data?: unknown;
+    type: string;
+}
+export type Class<T = object, A extends unknown[] = unknown[]> = new (...args: A) => T;
+export interface IExecuteFunctions extends IExecuteFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+        assertBinaryData(itemIndex: number, propertyName: string, inputIndex?: number): IBinaryData;
+        getBinaryDataBuffer(itemIndex: number, propertyName: string, inputIndex?: number): Promise<Buffer>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+        normalizeItems(items: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface IExecuteSingleFunctions extends IExecuteSingleFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface IPollFunctions extends IPollFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface IResponseError extends Error {
+    statusCode?: number;
+}
+export interface ITriggerFunctions extends ITriggerFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface ITriggerTime {
+    mode: string;
+    hour: number;
+    minute: number;
+    dayOfMonth: number;
+    weekeday: number;
+    [key: string]: string | number;
+}
+export interface IUserSettings {
+    encryptionKey?: string;
+    tunnelSubdomain?: string;
+    instanceId?: string;
+}
+export interface ILoadOptionsFunctions extends ILoadOptionsFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        request?: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2?: (this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options) => Promise<unknown>;
+        requestOAuth1?(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface ICredentialTestFunctions extends ICredentialTestFunctionsBase {
+    helpers: {
+        request?: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+    };
+}
+export interface IHookFunctions extends IHookFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface IWebhookFunctions extends IWebhookFunctionsBase {
+    helpers: {
+        httpRequest(requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+        prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+        request: (uriOrObject: string | IDataObject | unknown, options?: IDataObject) => Promise<unknown>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, oAuth2Options?: IOAuth2Options): Promise<unknown>;
+        requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | RequestPromiseOptions): Promise<unknown>;
+        returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions): Promise<IN8nHttpFullResponse | IN8nHttpResponse>;
+    };
+}
+export interface IWorkflowSettings extends IWorkflowSettingsWorkflow {
+    errorWorkflow?: string;
+    timezone?: string;
+    saveManualRuns?: boolean;
+}
+export interface INodeDefinitionFile {
+    [key: string]: Constructable<INodeType | ICredentialType>;
+}
+export interface INodeInputDataConnections {
+    [key: string]: INodeExecutionData[][];
+}
+export interface IWorkflowData {
+    pollResponses?: IPollResponse[];
+    triggerResponses?: ITriggerResponse[];
+}
+export interface IBinaryDataConfig {
+    mode: "default" | "filesystem";
+    availableModes: string;
+    localStoragePath: string;
+    binaryDataTTL: number;
+    persistedBinaryDataTTL: number;
+}
+export interface IBinaryDataManager {
+    init(startPurger: boolean): Promise<void>;
+    storeBinaryData(binaryBuffer: Buffer, executionId: string): Promise<string>;
+    retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer>;
+    markDataForDeletionByExecutionId(executionId: string): Promise<void>;
+    deleteMarkedFiles(): Promise<unknown>;
+    deleteBinaryDataByIdentifier(identifier: string): Promise<void>;
+    duplicateBinaryDataByIdentifier(binaryDataId: string, prefix: string): Promise<string>;
+    deleteBinaryDataByExecutionId(executionId: string): Promise<void>;
+    persistBinaryDataForExecutionId(executionId: string): Promise<void>;
+}
+export {};

package/dist/lib/Interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/LoadNodeParameterOptions.d.ts

@@ -0,0 +1,39 @@
+import { type ILoadOptions, type INode, type INodeCredentials, type INodeParameters, type INodePropertyOptions, type INodeTypeNameVersion, type INodeTypes, type IWorkflowExecuteAdditionalData, Workflow } from "@fsai-flow/workflow";
+export declare class LoadNodeParameterOptions {
+    currentNodeParameters: INodeParameters;
+    path: string;
+    workflow: Workflow;
+    constructor(nodeTypeNameAndVersion: INodeTypeNameVersion, nodeTypes: INodeTypes, path: string, currentNodeParameters: INodeParameters, credentials?: INodeCredentials);
+    /**
+     * Returns data of a fake workflow
+     *
+     * @returns
+     * @memberof LoadNodeParameterOptions
+     */
+    getWorkflowData(): {
+        name: string;
+        active: boolean;
+        connections: {};
+        nodes: INode[];
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    /**
+     * Returns the available options via a predefined method
+     *
+     * @param {string} methodName The name of the method of which to get the data from
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @returns {Promise<INodePropertyOptions[]>}
+     * @memberof LoadNodeParameterOptions
+     */
+    getOptionsViaMethodName(methodName: string, additionalData: IWorkflowExecuteAdditionalData): Promise<INodePropertyOptions[]>;
+    /**
+     * Returns the available options via a load request informatoin
+     *
+     * @param {ILoadOptions} loadOptions The load options which also contain the request information
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @returns {Promise<INodePropertyOptions[]>}
+     * @memberof LoadNodeParameterOptions
+     */
+    getOptionsViaRequestProperty(loadOptions: ILoadOptions, additionalData: IWorkflowExecuteAdditionalData): Promise<INodePropertyOptions[]>;
+}

package/dist/lib/LoadNodeParameterOptions.js

@@ -0,0 +1,152 @@
+"use strict";
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadNodeParameterOptions = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+// eslint-disable-next-line import/no-cycle
+const __1 = require("..");
+const TEMP_NODE_NAME = "Temp-Node";
+const TEMP_WORKFLOW_NAME = "Temp-Workflow";
+class LoadNodeParameterOptions {
+    constructor(nodeTypeNameAndVersion, nodeTypes, path, currentNodeParameters, credentials) {
+        const nodeType = nodeTypes.getByNameAndVersion(nodeTypeNameAndVersion.name, nodeTypeNameAndVersion.version);
+        this.currentNodeParameters = currentNodeParameters;
+        this.path = path;
+        if (nodeType === undefined) {
+            throw new Error(`The node-type "${nodeTypeNameAndVersion.name} v${nodeTypeNameAndVersion.version}"  is not known!`);
+        }
+        const nodeData = {
+            parameters: currentNodeParameters,
+            name: TEMP_NODE_NAME,
+            type: nodeTypeNameAndVersion.name,
+            typeVersion: nodeTypeNameAndVersion.version,
+            position: [0, 0],
+            id: "",
+        };
+        if (credentials) {
+            nodeData.credentials = credentials;
+        }
+        const workflowData = {
+            nodes: [nodeData],
+            connections: {},
+        };
+        this.workflow = new workflow_1.Workflow({
+            nodes: workflowData.nodes,
+            connections: workflowData.connections,
+            active: false,
+            nodeTypes,
+        });
+    }
+    /**
+     * Returns data of a fake workflow
+     *
+     * @returns
+     * @memberof LoadNodeParameterOptions
+     */
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    getWorkflowData() {
+        return {
+            name: TEMP_WORKFLOW_NAME,
+            active: false,
+            connections: {},
+            nodes: Object.values(this.workflow.nodes),
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+    }
+    /**
+     * Returns the available options via a predefined method
+     *
+     * @param {string} methodName The name of the method of which to get the data from
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @returns {Promise<INodePropertyOptions[]>}
+     * @memberof LoadNodeParameterOptions
+     */
+    async getOptionsViaMethodName(methodName, additionalData) {
+        const node = this.workflow.getNode(TEMP_NODE_NAME);
+        const nodeType = this.workflow.nodeTypes.getByNameAndVersion(node.type, node?.typeVersion);
+        if (!nodeType ||
+            nodeType.methods === undefined ||
+            nodeType.methods.loadOptions === undefined ||
+            nodeType.methods.loadOptions[methodName] === undefined) {
+            throw new Error(`The node-type "${node?.type}" does not have the method "${methodName}" defined!`);
+        }
+        const thisArgs = __1.NodeExecuteFunctions.getLoadOptionsFunctions(this.workflow, node, this.path, additionalData);
+        try {
+            return await nodeType.methods.loadOptions[methodName].call(thisArgs);
+        }
+        catch (error) {
+            return [
+                {
+                    name: "Error trying to load options",
+                    value: "",
+                    description: error.message || "Error trying to load options.",
+                },
+            ];
+        }
+    }
+    /**
+     * Returns the available options via a load request informatoin
+     *
+     * @param {ILoadOptions} loadOptions The load options which also contain the request information
+     * @param {IWorkflowExecuteAdditionalData} additionalData
+     * @returns {Promise<INodePropertyOptions[]>}
+     * @memberof LoadNodeParameterOptions
+     */
+    async getOptionsViaRequestProperty(loadOptions, additionalData) {
+        const node = this.workflow.getNode(TEMP_NODE_NAME);
+        const nodeType = this.workflow.nodeTypes.getByNameAndVersion(node.type, node?.typeVersion);
+        if (nodeType === undefined ||
+            !nodeType.description.requestDefaults ||
+            !nodeType.description.requestDefaults.baseURL) {
+            // This in in here for now for security reasons.
+            // Background: As the full data for the request to make does get send, and the auth data
+            // will then be applied, would it be possible to retrieve that data like that. By at least
+            // requiring a baseURL to be defined can at least not a random server be called.
+            // In the future this code has to get improved that it does not use the request information from
+            // the request rather resolves it via the parameter-path and nodeType data.
+            throw new Error(`The node-type "${node?.type}" does not exist or does not have "requestDefaults.baseURL" defined!`);
+        }
+        const mode = "internal";
+        const runIndex = 0;
+        const connectionInputData = [];
+        const runExecutionData = { resultData: { runData: {} } };
+        const routingNode = new workflow_1.RoutingNode(this.workflow, node, connectionInputData, runExecutionData ?? null, additionalData, mode);
+        // Create copy of node-type with the single property we want to get the data off
+        const tempNode = {
+            ...nodeType,
+            ...{
+                description: {
+                    ...nodeType.description,
+                    properties: [
+                        {
+                            displayName: "",
+                            type: "string",
+                            name: "",
+                            default: "",
+                            routing: loadOptions.routing,
+                        },
+                    ],
+                },
+            },
+        };
+        const inputData = {
+            main: [[{ json: {} }]],
+        };
+        const optionsData = await routingNode.runNode(inputData, runIndex, tempNode, __1.NodeExecuteFunctions);
+        if (optionsData?.length === 0) {
+            return [];
+        }
+        if (!Array.isArray(optionsData)) {
+            throw new Error("The returned data is not an array!");
+        }
+        return optionsData[0].map((item) => item.json);
+    }
+}
+exports.LoadNodeParameterOptions = LoadNodeParameterOptions;

package/dist/lib/NodeExecuteFunctions.d.ts

@@ -0,0 +1,225 @@
+import { type CloseFunction, type IAdditionalCredentialOptions, type IAllExecuteFunctions, type IBinaryData, type ICredentialDataDecryptedObject, type IDataObject, type IExecuteFunctions, type IExecuteSingleFunctions, type IHttpRequestOptions, type INode, type INodeExecutionData, type INodeParameters, type INodeType, type IOAuth2Options, type IPollFunctions, type IRunExecutionData, type ISupplyDataFunctions, type ITaskDataConnections, type ITriggerFunctions, type IWebhookData, type IWebhookDescription, type IWebhookFunctions, type IWorkflowDataProxyAdditionalKeys, type IWorkflowExecuteAdditionalData, type IWorkflowMetadata, type NodeConnectionType, type NodeParameterValue, type Workflow, type WorkflowActivateMode, type WorkflowExecuteMode } from "@fsai-flow/workflow";
+import { type ICredentialTestFunctions, type IHookFunctions, type ILoadOptionsFunctions } from "..";
+import type { OptionsWithUri, OptionsWithUrl, RequestPromiseOptions } from "./RequestTypes";
+/**
+ * Returns binary data buffer for given item index and property name.
+ *
+ * @export
+ * @param {ITaskDataConnections} inputData
+ * @param {number} itemIndex
+ * @param {string} propertyName
+ * @param {number} inputIndex
+ * @returns {Promise<Buffer>}
+ */
+export declare function getBinaryDataBuffer(inputData: ITaskDataConnections, itemIndex: number, propertyName: string, inputIndex: number): Promise<Buffer>;
+/**
+ * Takes a buffer and converts it into the format n8n uses. It encodes the binary data as
+ * base64 and adds metadata.
+ *
+ * @export
+ * @param {Buffer} binaryData
+ * @param {string} [filePath]
+ * @param {string} [mimeType]
+ * @returns {Promise<IBinaryData>}
+ */
+export declare function prepareBinaryData(binaryData: Buffer, executionId: string, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+export declare function getCurrentOAuth2AccessToken(this: IAllExecuteFunctions, credentialsType: string, node: INode, additionalData: IWorkflowExecuteAdditionalData, oAuth2Options?: IOAuth2Options): Promise<string>;
+export declare function requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions | IHttpRequestOptions, node: INode, additionalData: IWorkflowExecuteAdditionalData, oAuth2Options?: IOAuth2Options, isN8nRequest?: boolean): Promise<unknown>;
+export declare function requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUrl | OptionsWithUri | RequestPromiseOptions | IHttpRequestOptions, isN8nRequest?: boolean): Promise<unknown>;
+export declare function httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+/**
+ * Takes generic input data and brings it into the json format n8n uses.
+ *
+ * @export
+ * @param {(IDataObject | IDataObject[])} jsonData
+ * @returns {INodeExecutionData[]}
+ */
+export declare function returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+/**
+ * Automatically put the objects under a 'json' key and don't error,
+ * if some objects contain json/binary keys and others don't, throws error 'Inconsistent item format'
+ *
+ * @export
+ * @param {INodeExecutionData | INodeExecutionData[]} executionData
+ * @returns {INodeExecutionData[]}
+ */
+export declare function normalizeItems(executionData: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
+export declare function requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: OptionsWithUri | RequestPromiseOptions, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+/**
+ * Returns the additional keys for Expressions and Function-Nodes
+ *
+ * @export
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {(IWorkflowDataProxyAdditionalKeys)}
+ */
+export declare function getAdditionalKeys(additionalData: IWorkflowExecuteAdditionalData): IWorkflowDataProxyAdditionalKeys;
+/**
+ * Returns the requested decrypted credentials if the node has access to them.
+ *
+ * @export
+ * @param {Workflow} workflow Workflow which requests the data
+ * @param {INode} node Node which request the data
+ * @param {string} type The credential type to return
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {(ICredentialDataDecryptedObject | undefined)}
+ */
+export declare function getCredentials(workflow: Workflow, node: INode, type: string, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, runExecutionData?: IRunExecutionData | null, runIndex?: number, connectionInputData?: INodeExecutionData[], itemIndex?: number): Promise<ICredentialDataDecryptedObject | undefined>;
+/**
+ * Returns a copy of the node
+ *
+ * @export
+ * @param {INode} node
+ * @returns {INode}
+ */
+export declare function getNode(node: INode): INode;
+/**
+ * Returns the requested resolved (all expressions replaced) node parameters.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {(IRunExecutionData | null)} runExecutionData
+ * @param {number} runIndex
+ * @param {INodeExecutionData[]} connectionInputData
+ * @param {INode} node
+ * @param {string} parameterName
+ * @param {number} itemIndex
+ * @param {*} [fallbackValue]
+ * @returns {(NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object)}
+ */
+export declare function getNodeParameter(workflow: Workflow, runExecutionData: IRunExecutionData | null, runIndex: number, connectionInputData: INodeExecutionData[], node: INode, parameterName: string, itemIndex: number, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, fallbackValue?: unknown): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+/**
+ * Returns if execution should be continued even if there was an error.
+ *
+ * @export
+ * @param {INode} node
+ * @returns {boolean}
+ */
+export declare function continueOnFail(node: INode): boolean;
+/**
+ * Returns the webhook URL of the webhook with the given name
+ *
+ * @export
+ * @param {string} name
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {boolean} [isTest]
+ * @returns {(string | undefined)}
+ */
+export declare function getNodeWebhookUrl(name: string, workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, additionalKeys: IWorkflowDataProxyAdditionalKeys, isTest?: boolean): string | undefined;
+/**
+ * Returns the timezone for the workflow
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {string}
+ */
+export declare function getTimezone(workflow: Workflow, additionalData: IWorkflowExecuteAdditionalData): string;
+/**
+ * Returns the full webhook description of the webhook with the given name
+ *
+ * @export
+ * @param {string} name
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @returns {(IWebhookDescription | undefined)}
+ */
+export declare function getWebhookDescription(name: string, workflow: Workflow, node: INode): IWebhookDescription | undefined;
+/**
+ * Returns the workflow metadata
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @returns {IWorkflowMetadata}
+ */
+export declare function getWorkflowMetadata(workflow: Workflow): IWorkflowMetadata;
+/**
+ * Returns the execute functions the poll nodes have access to.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {ITriggerFunctions}
+ */
+export declare function getExecutePollFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): IPollFunctions;
+/**
+ * Returns the execute functions the trigger nodes have access to.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {ITriggerFunctions}
+ */
+export declare function getExecuteTriggerFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode): ITriggerFunctions;
+/**
+ * Returns the execute functions regular nodes have access to.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IRunExecutionData} runExecutionData
+ * @param {number} runIndex
+ * @param {INodeExecutionData[]} connectionInputData
+ * @param {ITaskDataConnections} inputData
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IExecuteFunctions}
+ */
+export declare function getExecuteFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, nodeTypeData: INodeType, closeFunctions: CloseFunction[]): IExecuteFunctions;
+/**
+ * Returns the execute functions regular nodes have access to when single-function is defined.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IRunExecutionData} runExecutionData
+ * @param {number} runIndex
+ * @param {INodeExecutionData[]} connectionInputData
+ * @param {ITaskDataConnections} inputData
+ * @param {INode} node
+ * @param {number} itemIndex
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IExecuteSingleFunctions}
+ */
+export declare function getExecuteSingleFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, itemIndex: number, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode): IExecuteSingleFunctions;
+export declare function getCredentialTestFunctions(): ICredentialTestFunctions;
+/**
+ * Returns the execute functions regular nodes have access to in load-options-function.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @returns {ILoadOptionsFunctions}
+ */
+export declare function getLoadOptionsFunctions(workflow: Workflow, node: INode, path: string, additionalData: IWorkflowExecuteAdditionalData): ILoadOptionsFunctions;
+/**
+ * Returns the execute functions regular nodes have access to in hook-function.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IHookFunctions}
+ */
+export declare function getExecuteHookFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode, isTest?: boolean, webhookData?: IWebhookData): IHookFunctions;
+/**
+ * Returns the execute functions regular nodes have access to when webhook-function is defined.
+ *
+ * @export
+ * @param {Workflow} workflow
+ * @param {IRunExecutionData} runExecutionData
+ * @param {INode} node
+ * @param {IWorkflowExecuteAdditionalData} additionalData
+ * @param {WorkflowExecuteMode} mode
+ * @returns {IWebhookFunctions}
+ */
+export declare function getExecuteWebhookFunctions(workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, webhookData: IWebhookData, initialRunExecutionData: IRunExecutionData | undefined): IWebhookFunctions;
+export declare function getSupplyDataFunctions(workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, nodeTypeData: INodeType, closeFunctions: CloseFunction[]): ISupplyDataFunctions;
+export declare function getInputConnectionData(this: IExecuteFunctions | ISupplyDataFunctions, workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, additionalData: IWorkflowExecuteAdditionalData, connectionType: NodeConnectionType, mode: WorkflowExecuteMode, itemIndex: number, nodeTypeData: INodeType, closeFunctions: CloseFunction[]): Promise<unknown>;