@fsai-flow/core 0.0.4 → 0.1.0

package/src/lib/FileSystem.ts

@@ -1,214 +0,0 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
-import { v4 as uuid } from 'uuid';
-
-import { IBinaryDataConfig, IBinaryDataManager } from './Interfaces';
-
-const PREFIX_METAFILE = 'binarymeta';
-const PREFIX_PERSISTED_METAFILE = 'persistedmeta';
-
-export class BinaryDataFileSystem implements IBinaryDataManager {
-	private storagePath: string;
-
-	private binaryDataTTL: number;
-
-	private persistedBinaryDataTTL: number;
-
-	constructor(config: IBinaryDataConfig) {
-		this.storagePath = config.localStoragePath;
-		this.binaryDataTTL = config.binaryDataTTL;
-		this.persistedBinaryDataTTL = config.persistedBinaryDataTTL;
-	}
-
-	async init(startPurger = false): Promise<void> {
-		if (startPurger) {
-			setInterval(async () => {
-				await this.deleteMarkedFiles();
-			}, this.binaryDataTTL * 30000);
-
-			setInterval(async () => {
-				await this.deleteMarkedPersistedFiles();
-			}, this.persistedBinaryDataTTL * 30000);
-		}
-
-		return fs
-			.readdir(this.storagePath)
-			.catch(async () => fs.mkdir(this.storagePath, { recursive: true }))
-			.then(async () => fs.readdir(this.getBinaryDataMetaPath()))
-			.catch(async () => fs.mkdir(this.getBinaryDataMetaPath(), { recursive: true }))
-			.then(async () => fs.readdir(this.getBinaryDataPersistMetaPath()))
-			.catch(async () => fs.mkdir(this.getBinaryDataPersistMetaPath(), { recursive: true }))
-			.then(async () => this.deleteMarkedFiles())
-			.then(async () => this.deleteMarkedPersistedFiles())
-			.then(() => {});
-	}
-
-	async storeBinaryData(binaryBuffer: Buffer, executionId: string): Promise<string> {
-		const binaryDataId = this.generateFileName(executionId);
-		return this.addBinaryIdToPersistMeta(executionId, binaryDataId).then(async () =>
-			this.saveToLocalStorage(binaryBuffer, binaryDataId).then(() => binaryDataId),
-		);
-	}
-
-	async retrieveBinaryDataByIdentifier(identifier: string): Promise<Buffer> {
-		return this.retrieveFromLocalStorage(identifier);
-	}
-
-	async markDataForDeletionByExecutionId(executionId: string): Promise<void> {
-		const tt = new Date(new Date().getTime() + this.binaryDataTTL * 60000);
-		return fs.writeFile(
-			path.join(this.getBinaryDataMetaPath(), `${PREFIX_METAFILE}_${executionId}_${tt.valueOf()}`),
-			'',
-		);
-	}
-
-	async deleteMarkedFiles(): Promise<void> {
-		return this.deleteMarkedFilesByMeta(this.getBinaryDataMetaPath(), PREFIX_METAFILE);
-	}
-
-	async deleteMarkedPersistedFiles(): Promise<void> {
-		return this.deleteMarkedFilesByMeta(
-			this.getBinaryDataPersistMetaPath(),
-			PREFIX_PERSISTED_METAFILE,
-		);
-	}
-
-	private async addBinaryIdToPersistMeta(executionId: string, identifier: string): Promise<void> {
-		const currentTime = new Date().getTime();
-		const timeAtNextHour = currentTime + 3600000 - (currentTime % 3600000);
-		const timeoutTime = timeAtNextHour + this.persistedBinaryDataTTL * 60000;
-
-		const filePath = path.join(
-			this.getBinaryDataPersistMetaPath(),
-			`${PREFIX_PERSISTED_METAFILE}_${executionId}_${timeoutTime}`,
-		);
-
-		return fs
-			.readFile(filePath)
-			.catch(async () => fs.writeFile(filePath, identifier))
-			.then(() => {});
-	}
-
-	private async deleteMarkedFilesByMeta(metaPath: string, filePrefix: string): Promise<void> {
-		const currentTimeValue = new Date().valueOf();
-		const metaFileNames = await fs.readdir(metaPath);
-
-		const execsAdded: { [key: string]: number } = {};
-
-		const proms = metaFileNames.reduce(
-			(prev, curr) => {
-				const [prefix, executionId, ts] = curr.split('_');
-
-				if (prefix !== filePrefix) {
-					return prev;
-				}
-
-				const execTimestamp = parseInt(ts, 10);
-
-				if (execTimestamp < currentTimeValue) {
-					if (execsAdded[executionId]) {
-						// do not delete data, only meta file
-						prev.push(this.deleteMetaFileByPath(path.join(metaPath, curr)));
-						return prev;
-					}
-
-					execsAdded[executionId] = 1;
-					prev.push(
-						this.deleteBinaryDataByExecutionId(executionId).then(async () =>
-							this.deleteMetaFileByPath(path.join(metaPath, curr)),
-						),
-					);
-				}
-
-				return prev;
-			},
-			[Promise.resolve()],
-		);
-
-		return Promise.all(proms).then(() => {});
-	}
-
-	async duplicateBinaryDataByIdentifier(binaryDataId: string, prefix: string): Promise<string> {
-		const newBinaryDataId = this.generateFileName(prefix);
-
-		return fs
-			.copyFile(
-				path.join(this.storagePath, binaryDataId),
-				path.join(this.storagePath, newBinaryDataId),
-			)
-			.then(() => newBinaryDataId);
-	}
-
-	async deleteBinaryDataByExecutionId(executionId: string): Promise<void> {
-		const regex = new RegExp(`${executionId}_*`);
-		const filenames = await fs.readdir(path.join(this.storagePath));
-
-		const proms = filenames.reduce(
-			(allProms, filename) => {
-				if (regex.test(filename)) {
-					allProms.push(fs.rm(path.join(this.storagePath, filename)));
-				}
-
-				return allProms;
-			},
-			[Promise.resolve()],
-		);
-
-		return Promise.all(proms).then(async () => Promise.resolve());
-	}
-
-	async deleteBinaryDataByIdentifier(identifier: string): Promise<void> {
-		return this.deleteFromLocalStorage(identifier);
-	}
-
-	async persistBinaryDataForExecutionId(executionId: string): Promise<void> {
-		return fs.readdir(this.getBinaryDataPersistMetaPath()).then(async (metafiles) => {
-			const proms = metafiles.reduce(
-				(prev, curr) => {
-					if (curr.startsWith(`${PREFIX_PERSISTED_METAFILE}_${executionId}_`)) {
-						prev.push(fs.rm(path.join(this.getBinaryDataPersistMetaPath(), curr)));
-						return prev;
-					}
-
-					return prev;
-				},
-				[Promise.resolve()],
-			);
-
-			return Promise.all(proms).then(() => {});
-		});
-	}
-
-	private generateFileName(prefix: string): string {
-		return `${prefix}_${uuid()}`;
-	}
-
-	private getBinaryDataMetaPath() {
-		return path.join(this.storagePath, 'meta');
-	}
-
-	private getBinaryDataPersistMetaPath() {
-		return path.join(this.storagePath, 'persistMeta');
-	}
-
-	private async deleteMetaFileByPath(metafilePath: string): Promise<void> {
-		return fs.rm(metafilePath);
-	}
-
-	private async deleteFromLocalStorage(identifier: string) {
-		return fs.rm(path.join(this.storagePath, identifier));
-	}
-
-	private async saveToLocalStorage(data: Buffer, identifier: string) {
-		await fs.writeFile(path.join(this.storagePath, identifier), data);
-	}
-
-	private async retrieveFromLocalStorage(identifier: string): Promise<Buffer> {
-		const filePath = path.join(this.storagePath, identifier);
-		try {
-			return await fs.readFile(filePath);
-		} catch (e) {
-			throw new Error(`Error finding file: ${filePath}`);
-		}
-	}
-}

package/src/lib/InputConnectionDataLegacy.ts

@@ -1,123 +0,0 @@
-import {
-    INode,
-    INodeType,
-    IExecuteFunctions,
-    ISupplyDataFunctions,
-    INodeInputConfiguration,
-    INodeTypeDescription,
-    Workflow,
-    SupplyData,
-    NodeConnectionType,
-    NodeOperationError,
-    IWebhookFunctions,
-} from '@fsai-flow/workflow';
-
-export async function getInputConnectionDataLegacy(
-    this:  ISupplyDataFunctions | IWebhookFunctions,
-    workflow: Workflow,
-    connectionType: NodeConnectionType,
-    itemIndex: number,
-    nodeTypeData: INodeType
-): Promise<unknown> {
-    const parentNode = this.getNode();
-
-    const nodeInputs = getNodeInputs(workflow, parentNode, nodeTypeData.description).map(
-        (input) => (typeof input === 'string' ? { type: input } : input),
-    ) as INodeInputConfiguration[];
-    const inputConfiguration = nodeInputs.find((input) => input.type === connectionType);
-    if (inputConfiguration === undefined) {
-        throw new NodeOperationError(
-            parentNode,
-            `Node does not have input of type`,
-            {
-                description: `Node ${parentNode.name} does not have input of type ${connectionType}`,
-            }
-        );
-    }
-
-    const connectedNodes = getConnectedNodes(workflow, parentNode, connectionType);
-    if (connectedNodes.length === 0) {
-        if (inputConfiguration.required) {
-            throw new NodeOperationError(
-                parentNode,
-                `A ${inputConfiguration?.displayName ?? connectionType} sub-node must be connected and enabled`,
-            );
-        }
-        return inputConfiguration.maxConnections === 1 ? undefined : [];
-    }
-
-    if (
-        inputConfiguration.maxConnections !== undefined &&
-        connectedNodes.length > inputConfiguration.maxConnections
-    ) {
-        throw new NodeOperationError(
-            parentNode,
-            `Only ${inputConfiguration.maxConnections} ${connectionType} sub-nodes are/is allowed to be connected`,
-        );
-    }
-
-    const nodes: SupplyData[] = [];
-    for (const connectedNode of connectedNodes) {
-        const connectedNodeType = workflow.nodeTypes.getByNameAndVersion(
-            connectedNode.type,
-            connectedNode.typeVersion,
-        );
-
-        if (!connectedNodeType) {
-            continue;
-        }
-
-        if (connectedNodeType && !connectedNodeType.supplyData) {
-            throw new NodeOperationError(connectedNode, 'Node does not have a `supplyData` method defined', {
-                itemIndex,
-            });
-        } else {
-            try {
-                const supplyData = await connectedNodeType.supplyData?.call(this, itemIndex);
-                if (supplyData) {
-                    nodes.push(supplyData);
-                }
-            } catch (error: any) {
-                throw new NodeOperationError(connectedNode, `Error in sub-node ${connectedNode.name}`, {
-                    itemIndex,
-                    description: error?.message ?? 'Unknown error',
-                });
-            }
-        }
-    }
-
-    return inputConfiguration.maxConnections === 1
-        ? (nodes || [])[0]?.response
-        : nodes.map((node) => node.response);
-}
-
-function getNodeInputs(
-    workflow: Workflow,
-    node: INode,
-    nodeTypeData: INodeTypeDescription,
-): Array<NodeConnectionType | INodeInputConfiguration> {
-    if (Array.isArray(nodeTypeData?.inputs)) {
-        return nodeTypeData.inputs as Array<NodeConnectionType | INodeInputConfiguration>;
-    }
-
-    // Calculate the outputs dynamically
-    try {
-        return (workflow.expression.getSimpleParameterValue(
-            node,
-            nodeTypeData.inputs,
-            'internal',
-            {},
-        ) || []) as NodeConnectionType[];
-    } catch (e) {
-        console.warn('Could not calculate inputs dynamically for node: ', node.name);
-        return [];
-    }
-}
-
-function getConnectedNodes(workflow: Workflow, node: INode, connectionType: NodeConnectionType) {
-    return workflow
-        .getParentNodes(node.name, connectionType, 1)
-        .map((nodeName) => workflow.getNode(nodeName))
-        .filter((node) => !!node)
-        .filter((node) => node.disabled !== true);
-}

package/src/lib/Interfaces.ts

@@ -1,338 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-	IAdditionalCredentialOptions,
-	IAllExecuteFunctions,
-	IBinaryData,
-	ICredentialTestFunctions as ICredentialTestFunctionsBase,
-	ICredentialType,
-	IDataObject,
-	IExecuteFunctions as IExecuteFunctionsBase,
-	IExecuteSingleFunctions as IExecuteSingleFunctionsBase,
-	IHookFunctions as IHookFunctionsBase,
-	IHttpRequestOptions,
-	ILoadOptionsFunctions as ILoadOptionsFunctionsBase,
-	INodeExecutionData,
-	INodeType,
-	IOAuth2Options,
-	IPollFunctions as IPollFunctionsBase,
-	IPollResponse,
-	ITriggerFunctions as ITriggerFunctionsBase,
-	ITriggerResponse,
-	IWebhookFunctions as IWebhookFunctionsBase,
-	IWorkflowSettings as IWorkflowSettingsWorkflow,
-} from '@fsai-flow/workflow';
-
-import { OptionsWithUri, OptionsWithUrl } from 'request';
-import * as requestPromise from 'request-promise-native';
-
-interface Constructable<T> {
-	new (): T;
-}
-
-export interface IProcessMessage {
-	data?: any;
-	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<any>; // tslint:disable-line:no-any
-		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 | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		): Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-		normalizeItems(items: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-export interface IExecuteSingleFunctions extends IExecuteSingleFunctionsBase {
-	helpers: {
-		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
-		prepareBinaryData(
-			binaryData: Buffer,
-			filePath?: string,
-			mimeType?: string,
-		): Promise<IBinaryData>;
-		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		): Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-export interface IPollFunctions extends IPollFunctionsBase {
-	helpers: {
-		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
-		prepareBinaryData(
-			binaryData: Buffer,
-			filePath?: string,
-			mimeType?: string,
-		): Promise<IBinaryData>;
-		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		): Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-export interface IResponseError extends Error {
-	statusCode?: number;
-}
-
-export interface ITriggerFunctions extends ITriggerFunctionsBase {
-	helpers: {
-		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
-		prepareBinaryData(
-			binaryData: Buffer,
-			filePath?: string,
-			mimeType?: string,
-		): Promise<IBinaryData>;
-		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		): Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-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<any>; // tslint:disable-line:no-any
-		request?: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2?: (
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		) => Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1?(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-export interface ICredentialTestFunctions extends ICredentialTestFunctionsBase {
-	helpers: {
-		request?: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-	};
-}
-
-export interface IHookFunctions extends IHookFunctionsBase {
-	helpers: {
-		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
-		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		): Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-export interface IWebhookFunctions extends IWebhookFunctionsBase {
-	helpers: {
-		httpRequest(requestOptions: IHttpRequestOptions): Promise<any>; // tslint:disable-line:no-any
-		prepareBinaryData(
-			binaryData: Buffer,
-			filePath?: string,
-			mimeType?: string,
-		): Promise<IBinaryData>;
-		request: (uriOrObject: string | IDataObject | any, options?: IDataObject) => Promise<any>; // tslint:disable-line:no-any
-		requestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			additionalCredentialOptions?: IAdditionalCredentialOptions,
-		): Promise<any>;
-		requestOAuth2(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUri | requestPromise.RequestPromiseOptions,
-			oAuth2Options?: IOAuth2Options,
-		): Promise<any>; // tslint:disable-line:no-any
-		requestOAuth1(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: OptionsWithUrl | requestPromise.RequestPromiseOptions,
-		): Promise<any>; // tslint:disable-line:no-any
-		returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
-		httpRequestWithAuthentication(
-			this: IAllExecuteFunctions,
-			credentialsType: string,
-			requestOptions: IHttpRequestOptions,
-		): Promise<any>;
-	};
-}
-
-export interface IWorkflowSettings extends IWorkflowSettingsWorkflow {
-	errorWorkflow?: string;
-	timezone?: string;
-	saveManualRuns?: boolean;
-}
-
-// New node definition in file
-export interface INodeDefinitionFile {
-	[key: string]: Constructable<INodeType | ICredentialType>;
-}
-
-// Is identical to TaskDataConnections but does not allow null value to be used as input for nodes
-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>;
-}