@fsai-flow/workflow 0.0.1

package/src/lib/Interfaces.ts

@@ -0,0 +1,2229 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable import/no-cycle */
+// eslint-disable-next-line import/no-extraneous-dependencies
+// eslint-disable-next-line max-classes-per-file
+import * as express from 'express';
+import * as FormData from 'form-data';
+import { URLSearchParams } from 'url';
+import { IDeferredPromise } from './DeferredPromise';
+import { WorkflowHooks } from './WorkflowHooks';
+import { WorkflowOperationError } from './WorkflowErrors';
+import { NodeApiError, NodeOperationError } from './NodeErrors';
+import { Workflow } from './Workflow';
+import { CODE_EXECUTION_MODES, CODE_LANGUAGES, LOG_LEVELS } from './Constants';
+
+export interface IAdditionalCredentialOptions {
+	oauth2?: IOAuth2Options;
+	credentialsDecrypted?: ICredentialsDecrypted;
+}
+
+export type IAllExecuteFunctions =
+	| IExecuteFunctions
+	| IExecutePaginationFunctions
+	| IExecuteSingleFunctions
+	| IHookFunctions
+	| ILoadOptionsFunctions
+	| IPollFunctions
+	| ITriggerFunctions
+	| IWebhookFunctions
+	| ISupplyDataFunctions;
+
+export interface IBinaryData {
+	[key: string]: string | undefined;
+	data: string;
+	mimeType: string;
+	fileName?: string;
+	directory?: string;
+	fileExtension?: string;
+	id?: string;
+}
+
+export interface IOAuth2Options {
+	includeCredentialsOnRefreshOnBody?: boolean;
+	property?: string;
+	tokenType?: string;
+	keepBearer?: boolean;
+	tokenExpiredStatusCode?: number;
+}
+
+export interface IConnection {
+	// The node the connection is to
+	node: string;
+
+	// The type of the input on destination node (for example "main")
+	type: string;
+
+	// The output/input-index of destination node (if node has multiple inputs/outputs of the same type)
+	index: number;
+}
+
+export type ExecutionError = WorkflowOperationError | NodeOperationError | NodeApiError;
+
+// Get used to gives nodes access to credentials
+export interface IGetCredentials {
+	get(type: string, id: string | null): Promise<ICredentialsEncrypted>;
+}
+
+export abstract class ICredentials {
+	id?: string;
+
+	name: string;
+
+	type: string;
+
+	data: string | undefined;
+
+	nodesAccess: ICredentialNodeAccess[];
+
+	constructor(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+		nodesAccess: ICredentialNodeAccess[],
+		data?: string,
+	) {
+		// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+		this.id = nodeCredentials.id || undefined;
+		this.name = nodeCredentials.name;
+		this.type = type;
+		this.nodesAccess = nodesAccess;
+		this.data = data;
+	}
+
+	abstract getData(encryptionKey: string, nodeType?: string): ICredentialDataDecryptedObject;
+
+	abstract getDataKey(key: string, encryptionKey: string, nodeType?: string): CredentialInformation;
+
+	abstract getDataToSave(): ICredentialsEncrypted;
+
+	abstract hasNodeAccess(nodeType: string): boolean;
+
+	abstract setData(data: ICredentialDataDecryptedObject, encryptionKey: string): void;
+
+	abstract setDataKey(key: string, data: CredentialInformation, encryptionKey: string): void;
+}
+
+// Defines which nodes are allowed to access the credentials and
+// when that access got grented from which user
+export interface ICredentialNodeAccess {
+	nodeType: string;
+	user?: string;
+	date?: Date;
+}
+
+export interface ICredentialsDecrypted {
+	id: string | number;
+	name: string;
+	type: string;
+	nodesAccess: ICredentialNodeAccess[];
+	data?: ICredentialDataDecryptedObject;
+}
+
+export interface ICredentialsEncrypted {
+	id?: string | number;
+	name: string;
+	type: string;
+	nodesAccess: ICredentialNodeAccess[];
+	data?: string;
+}
+
+export type NodeTypeAndVersion = {
+	name: string;
+	type: string;
+	typeVersion: number;
+	disabled: boolean;
+	parameters?: INodeParameters;
+};
+
+export interface ICredentialsExpressionResolveValues {
+	connectionInputData: INodeExecutionData[];
+	itemIndex: number;
+	node: INode;
+	runExecutionData: IRunExecutionData | null;
+	runIndex: number;
+	workflow: Workflow;
+}
+
+// Simplified options of request library
+export interface IRequestOptionsSimplified {
+	auth?: {
+		username: string;
+		password: string;
+	};
+	body: IDataObject;
+	headers: IDataObject;
+	qs: IDataObject;
+}
+
+export abstract class ICredentialsHelper {
+	encryptionKey: string;
+
+	constructor(encryptionKey: string) {
+		this.encryptionKey = encryptionKey;
+	}
+
+	abstract getParentTypes(name: string): string[];
+
+	abstract authenticate(
+		credentials: ICredentialDataDecryptedObject,
+		typeName: string,
+		requestOptions: IHttpRequestOptions | IRequestOptionsSimplified,
+		workflow: Workflow,
+		node: INode,
+	): Promise<IHttpRequestOptions>;
+
+	abstract getCredentials(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+	): Promise<ICredentials>;
+
+	abstract getDecrypted(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+		mode: WorkflowExecuteMode,
+		raw?: boolean,
+		expressionResolveValues?: ICredentialsExpressionResolveValues,
+	): Promise<ICredentialDataDecryptedObject>;
+
+	abstract updateCredentials(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+		data: ICredentialDataDecryptedObject,
+	): Promise<void>;
+}
+
+export interface IAuthenticateBase {
+	type: string;
+	properties: {
+		[key: string]: string;
+	};
+}
+
+export abstract class Node {
+	abstract description: INodeTypeDescription;
+	execute?(context: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+	webhook?(context: IWebhookFunctions): Promise<IWebhookResponseData>;
+	poll?(context: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+}
+
+export interface IAuthenticateBasicAuth extends IAuthenticateBase {
+	type: 'basicAuth';
+	properties: {
+		userPropertyName?: string;
+		passwordPropertyName?: string;
+	};
+}
+
+export interface IAuthenticateBearer extends IAuthenticateBase {
+	type: 'bearer';
+	properties: {
+		tokenPropertyName?: string;
+	};
+}
+
+export interface IAuthenticateHeaderAuth extends IAuthenticateBase {
+	type: 'headerAuth';
+	properties: {
+		name: string;
+		value: string;
+	};
+}
+
+export interface IAuthenticateQueryAuth extends IAuthenticateBase {
+	type: 'queryAuth';
+	properties: {
+		key: string;
+		value: string;
+	};
+}
+
+export type IAuthenticate =
+	| ((
+		credentials: ICredentialDataDecryptedObject,
+		requestOptions: IHttpRequestOptions,
+	) => Promise<IHttpRequestOptions>)
+	| IAuthenticateBasicAuth
+	| IAuthenticateBearer
+	| IAuthenticateHeaderAuth
+	| IAuthenticateQueryAuth;
+
+export interface IAuthenticateRuleBase {
+	type: string;
+	properties: {
+		[key: string]: string | number;
+	};
+	errorMessage?: string;
+}
+
+export interface IAuthenticateRuleResponseCode extends IAuthenticateRuleBase {
+	type: 'responseCode';
+	properties: {
+		value: number;
+		message: string;
+	};
+}
+
+export interface ICredentialTestRequest {
+	request: IHttpRequestOptions;
+	rules?: IAuthenticateRuleResponseCode[];
+}
+
+export interface ICredentialTestRequestData {
+	nodeType?: INodeType;
+	testRequest: ICredentialTestRequest;
+}
+
+export type IconRef = `fa:${string}` | `node:${string}.${string}`;
+export type IconFile = `file:${string}.png` | `file:${string}.svg`;
+export type Icon = IconRef | Themed<IconFile>;
+
+type ICredentialHttpRequestNode = {
+	name: string;
+	docsUrl: string;
+	hidden?: boolean;
+} & ({ apiBaseUrl: string } | { apiBaseUrlPlaceholder: string });
+
+export interface ICredentialType {
+	name: string;
+	displayName: string;
+	icon?: Icon | string;
+	iconColor?: ThemeIconColor;
+	iconUrl?: Themed<string>;
+	extends?: string[];
+	properties: INodeProperties[];
+	documentationUrl?: string;
+	__overwrittenProperties?: string[];
+	authenticate?: IAuthenticate;
+	test?: ICredentialTestRequest;
+	httpRequestNode?: ICredentialHttpRequestNode;
+	supportedNodes?: string[];
+}
+
+export interface ICredentialTypes {
+	credentialTypes?: ICredentialTypeData;
+	init(credentialTypes?: ICredentialTypeData): Promise<void>;
+	getAll(): ICredentialType[];
+	getByName(credentialType: string): ICredentialType;
+}
+
+// The way the credentials get saved in the database (data encrypted)
+export interface ICredentialData {
+	id?: string;
+	name: string;
+	data: string; // Contains the access data as encrypted JSON string
+	nodesAccess: ICredentialNodeAccess[];
+}
+
+// The encrypted credentials which the nodes can access
+export type CredentialInformation = string | number | boolean | IDataObject;
+
+// The encrypted credentials which the nodes can access
+export interface ICredentialDataDecryptedObject {
+	[key: string]: CredentialInformation;
+}
+
+// First array index: The output/input-index (if node has multiple inputs/outputs of the same type)
+// Second array index: The different connections (if one node is connected to multiple nodes)
+export type NodeInputConnections = IConnection[][];
+
+export interface INodeConnections {
+	// Input name
+	[key: string]: NodeInputConnections;
+}
+
+export interface IConnections {
+	// Node name
+	[key: string]: INodeConnections;
+}
+
+export type GenericValue = string | object | number | boolean | undefined | null;
+
+// export type IExecuteResponsePromiseData = IDataObject;
+export type IExecuteResponsePromiseData = IDataObject | IN8nHttpFullResponse;
+
+export interface INodeTypeNameVersion {
+	name: string;
+	version: number;
+}
+
+export interface IGetExecutePollFunctions {
+	(
+		workflow: Workflow,
+		node: INode,
+		additionalData: IWorkflowExecuteAdditionalData,
+		mode: WorkflowExecuteMode,
+		activation: WorkflowActivateMode,
+	): IPollFunctions;
+}
+
+export interface IGetExecuteTriggerFunctions {
+	(
+		workflow: Workflow,
+		node: INode,
+		additionalData: IWorkflowExecuteAdditionalData,
+		mode: WorkflowExecuteMode,
+		activation: WorkflowActivateMode,
+	): ITriggerFunctions;
+}
+
+export interface IGetExecuteFunctions {
+	(
+		workflow: Workflow,
+		runExecutionData: IRunExecutionData,
+		runIndex: number,
+		connectionInputData: INodeExecutionData[],
+		inputData: ITaskDataConnections,
+		node: INode,
+		additionalData: IWorkflowExecuteAdditionalData,
+		mode: WorkflowExecuteMode,
+		nodeTypeData: INodeType,
+		closeFunctions: CloseFunction[],
+	): IExecuteFunctions;
+}
+
+export interface IGetExecuteSingleFunctions {
+	(
+		workflow: Workflow,
+		runExecutionData: IRunExecutionData,
+		runIndex: number,
+		connectionInputData: INodeExecutionData[],
+		inputData: ITaskDataConnections,
+		node: INode,
+		itemIndex: number,
+		additionalData: IWorkflowExecuteAdditionalData,
+		mode: WorkflowExecuteMode,
+	): IExecuteSingleFunctions;
+}
+
+export interface IGetExecuteHookFunctions {
+	(
+		workflow: Workflow,
+		node: INode,
+		additionalData: IWorkflowExecuteAdditionalData,
+		mode: WorkflowExecuteMode,
+		activation: WorkflowActivateMode,
+		isTest?: boolean,
+		webhookData?: IWebhookData,
+	): IHookFunctions;
+}
+
+export interface IGetExecuteWebhookFunctions {
+	(
+		workflow: Workflow,
+		node: INode,
+		additionalData: IWorkflowExecuteAdditionalData,
+		mode: WorkflowExecuteMode,
+		webhookData: IWebhookData,
+		runExecutionData: IRunExecutionData | undefined,
+	): IWebhookFunctions;
+}
+
+export interface IExecuteData {
+	data: ITaskDataConnections;
+	node: INode;
+}
+
+export type IContextObject = {
+	[key: string]: any;
+};
+
+export interface IExecuteContextData {
+	// Keys are: "flow" | "node:<NODE_NAME>"
+	[key: string]: IContextObject;
+}
+
+export type IHttpRequestMethods = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
+
+export interface IHttpRequestOptions {
+	url: string;
+	baseURL?: string;
+	headers?: IDataObject;
+	method?: IHttpRequestMethods;
+	body?: FormData | GenericValue | GenericValue[] | Buffer | URLSearchParams;
+	qs?: IDataObject;
+	arrayFormat?: 'indices' | 'brackets' | 'repeat' | 'comma';
+	auth?: {
+		username: string;
+		password: string;
+	};
+	disableFollowRedirect?: boolean;
+	encoding?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream';
+	skipSslCertificateValidation?: boolean;
+	returnFullResponse?: boolean;
+	ignoreHttpStatusErrors?: boolean;
+	proxy?: {
+		host: string;
+		port: number;
+		auth?: {
+			username: string;
+			password: string;
+		};
+		protocol?: string;
+	};
+	timeout?: number;
+	json?: boolean;
+}
+
+export type IN8nHttpResponse = IDataObject | Buffer | GenericValue | GenericValue[] | null;
+
+export interface IN8nHttpFullResponse {
+	body: IN8nHttpResponse;
+	headers: IDataObject;
+	statusCode: number;
+	statusMessage?: string;
+}
+
+export interface IN8nRequestOperations {
+	pagination?:
+	| IN8nRequestOperationPaginationOffset
+	| ((
+		this: IExecutePaginationFunctions,
+		requestOptions: IRequestOptionsFromParameters,
+	) => Promise<INodeExecutionData[]>);
+}
+
+export interface IN8nRequestOperationPaginationBase {
+	type: string;
+	properties: {
+		[key: string]: string | number;
+	};
+}
+
+export interface IN8nRequestOperationPaginationOffset extends IN8nRequestOperationPaginationBase {
+	type: 'offset';
+	properties: {
+		limitParameter: string;
+		offsetParameter: string;
+		pageSize: number;
+		rootProperty?: string; // Optional Path to option array
+		type: 'body' | 'query';
+	};
+}
+
+export interface ITaskSubRunMetadata {
+	node: string;
+	runIndex: number;
+}
+
+export interface RelatedExecution {
+	executionId: string;
+	workflowId: string;
+}
+
+export interface ITaskMetadata {
+	subRun?: ITaskSubRunMetadata[];
+	parentExecution?: RelatedExecution;
+	subExecution?: RelatedExecution;
+	subExecutionsCount?: number;
+}
+
+export type AINodeConnectionType = Exclude<NodeConnectionType, typeof NodeConnectionTypes.Main>;
+
+namespace RecordReturning {
+	export type NodeParameter = 'additionalFields' | 'filters' | 'options' | 'updateFields';
+}
+
+export interface IExecuteFunctions {
+	continueOnFail(): boolean;
+	evaluateExpression(
+		expression: string,
+		itemIndex: number,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[];
+	executeWorkflow(
+		workflowInfo: IExecuteWorkflowInfo,
+		inputData?: INodeExecutionData[],
+	): Promise<any>;
+	getContext(type: string): IContextObject;
+	getCredentials(
+		type: string,
+		itemIndex?: number,
+	): Promise<ICredentialDataDecryptedObject | undefined>;
+	getCredentials<T extends object = ICredentialDataDecryptedObject>(
+		type: string,
+		itemIndex?: number,
+	): Promise<T>;
+	getInputData(inputIndex?: number, inputName?: string): INodeExecutionData[];
+	getInstanceId(): string;
+	getMode(): WorkflowExecuteMode;
+	getNode(): INode;
+	getNodeParameter<T extends { resource: string }>(
+		parameterName: 'resource',
+		itemIndex?: number,
+	): T['resource'];
+	// getNodeParameter(parameterName: 'operation', itemIndex?: number): string;
+	getNodeParameter(
+		parameterName: string,
+		itemIndex: number,
+		fallbackValue?: any,
+		options?: IGetNodeParameterOptions,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getNodeParameter(
+		parameterName: RecordReturning.NodeParameter,
+		itemIndex: number,
+		fallbackValue?: IDataObject,
+		options?: IGetNodeParameterOptions,
+	): IDataObject;
+	getExecutionCancelSignal(): AbortSignal | undefined;
+	getWorkflowDataProxy(itemIndex: number): IWorkflowDataProxyData;
+	getWorkflowStaticData(type: string): IDataObject;
+	getRestApiUrl(): string;
+	getTimezone(): string;
+	getWorkflow(): IWorkflowMetadata;
+	prepareOutputData(
+		outputData: INodeExecutionData[],
+		outputIndex?: number,
+	): Promise<INodeExecutionData[][]>;
+	putExecutionToWait(waitTill: Date): Promise<void>;
+	sendMessageToUI(message: any): void; // tslint:disable-line:no-any
+	sendResponse(response: IExecuteResponsePromiseData): void; // tslint:disable-line:no-any
+	addInputData(
+		data: INodeExecutionData[][] | ExecutionError,
+		node: INode,
+	): { index: number, inputExecutionData: IRunExecutionData };
+	addOutputData(
+		data: INodeExecutionData[][] | ExecutionError,
+		node: INode,
+	): { outputExecutionData: IRunExecutionData };
+	getInputConnectionData(
+		connectionType: AINodeConnectionType,
+		itemIndex: number,
+		inputIndex?: number,
+	): Promise<unknown>;
+	getNodeOutputs?(): INodeOutputConfiguration[];
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		assertBinaryData(itemIndex: number, propertyName: string, inputIndex?: number): IBinaryData;
+		getBinaryDataBuffer(itemIndex: number, propertyName: string, inputIndex?: number): Promise<Buffer>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+}
+
+export interface INodeInputFilter {
+	nodes: string[];
+}
+
+export interface INodeInputConfiguration {
+	category?: string;
+	displayName?: string;
+	required?: boolean;
+	type: NodeConnectionType;
+	filter?: INodeInputFilter;
+	maxConnections?: number;
+}
+
+export interface INodeOutputConfiguration {
+	category?: 'error';
+	displayName?: string;
+	maxConnections?: number;
+	required?: boolean;
+	type: NodeConnectionType;
+}
+
+export type ISupplyDataFunctions = {
+	logger: Logger;
+	continueOnFail(): boolean;
+	evaluateExpression(
+		expression: string,
+		itemIndex: number,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[];
+	executeWorkflow(
+		workflowInfo: IExecuteWorkflowInfo,
+		inputData?: INodeExecutionData[],
+	): Promise<any>;
+	getContext(type: string): IContextObject;
+	getCredentials(
+		type: string,
+		itemIndex?: number,
+	): Promise<ICredentialDataDecryptedObject | undefined>;
+	getInputData(inputIndex?: number, inputName?: string): INodeExecutionData[];
+	getInstanceId(): string;
+	getMode(): WorkflowExecuteMode;
+	getNode(): INode;
+	getNodeParameter<T extends { resource: string }>(
+		parameterName: 'resource',
+		itemIndex?: number,
+	): T['resource'];
+	getNodeParameter(
+		parameterName: string,
+		itemIndex: number,
+		fallbackValue?: any,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getWorkflowDataProxy(itemIndex: number): IWorkflowDataProxyData;
+	getWorkflowStaticData(type: string): IDataObject;
+	getRestApiUrl(): string;
+	getTimezone(): string;
+	getWorkflow(): IWorkflowMetadata;
+	prepareOutputData(
+		outputData: INodeExecutionData[],
+		outputIndex?: number,
+	): Promise<INodeExecutionData[][]>;
+	putExecutionToWait(waitTill: Date): Promise<void>;
+	sendMessageToUI(message: any): void; // tslint:disable-line:no-any
+	sendResponse(response: IExecuteResponsePromiseData): void; // tslint:disable-line:no-any
+	
+	getInputConnectionData(
+		connectionType: NodeConnectionType,
+		itemIndex: number,
+		inputIndex?: number,
+	): Promise<unknown>;
+	addInputData(
+		data: INodeExecutionData[][] | ExecutionError,
+		node: INode,
+	): { index: number, inputExecutionData: IRunExecutionData };
+	addOutputData(
+		data: INodeExecutionData[][] | ExecutionError,
+		node: INode,
+	): { outputExecutionData: IRunExecutionData };
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		assertBinaryData(itemIndex: number, propertyName: string, inputIndex?: number): IBinaryData;
+		getBinaryDataBuffer(itemIndex: number, propertyName: string, inputIndex?: number): Promise<Buffer>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+}
+
+export interface IExecuteSingleFunctions {
+	continueOnFail(): boolean;
+	evaluateExpression(
+		expression: string,
+		itemIndex: number | undefined,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[];
+	getContext(type: string): IContextObject;
+	getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+	getInputData(inputIndex?: number, inputName?: string): INodeExecutionData;
+	getMode(): WorkflowExecuteMode;
+	getNode(): INode;
+	getNodeParameter(
+		parameterName: string,
+		fallbackValue?: any,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getRestApiUrl(): string;
+	getTimezone(): string;
+	getWorkflow(): IWorkflowMetadata;
+	getWorkflowDataProxy(): IWorkflowDataProxyData;
+	getWorkflowStaticData(type: string): IDataObject;
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+}
+
+export interface IExecutePaginationFunctions extends IExecuteSingleFunctions {
+	makeRoutingRequest(
+		this: IAllExecuteFunctions,
+		requestOptions: IRequestOptionsFromParameters,
+	): Promise<INodeExecutionData[]>;
+}
+export interface IExecuteWorkflowInfo {
+	code?: IWorkflowBase;
+	id?: string;
+}
+
+export type ICredentialTestFunction = (
+	this: ICredentialTestFunctions,
+	credential: ICredentialsDecrypted,
+) => Promise<INodeCredentialTestResult>;
+
+export interface ICredentialTestFunctions {
+	helpers: {
+		[key: string]: (...args: any[]) => any;
+	};
+}
+
+export interface ILoadOptionsFunctions {
+	getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+	getNode(): INode;
+	getNodeParameter(
+		parameterName: string,
+		fallbackValue?: any,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getCurrentNodeParameter(
+		parameterName: string,
+	):
+		| NodeParameterValue
+		| INodeParameters
+		| NodeParameterValue[]
+		| INodeParameters[]
+		| object
+		| undefined;
+	getCurrentNodeParameters(): INodeParameters | undefined;
+	getTimezone(): string;
+	getRestApiUrl(): string;
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		// TODO: Remove from here. Add it only now to LoadOptions as many nodes do import
+		//       from @fsai-flow/workflow instead of n8n-core
+		requestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: any, // tslint:disable-line:no-any
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<any>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		[key: string]: ((...args: any[]) => any) | undefined; // tslint:disable-line:no-any
+	};
+}
+
+export interface IHookFunctions {
+	getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+	getMode(): WorkflowExecuteMode;
+	getActivationMode(): WorkflowActivateMode;
+	getNode(): INode;
+	getNodeWebhookUrl: (name: string) => string | undefined;
+	getNodeParameter(
+		parameterName: string,
+		fallbackValue?: any,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getTimezone(): string;
+	getWebhookDescription(name: string): IWebhookDescription | undefined;
+	getWebhookName(): string;
+	getWorkflow(): IWorkflowMetadata;
+	getWorkflowStaticData(type: string): IDataObject;
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+}
+
+export interface IPollFunctions {
+	__emit(data: INodeExecutionData[][]): void;
+	getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+	getMode(): WorkflowExecuteMode;
+	getActivationMode(): WorkflowActivateMode;
+	getNode(): INode;
+	getNodeParameter(
+		parameterName: string,
+		fallbackValue?: any,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getRestApiUrl(): string;
+	getTimezone(): string;
+	getWorkflow(): IWorkflowMetadata;
+	getWorkflowStaticData(type: string): IDataObject;
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+}
+
+export interface ITriggerFunctions {
+	emit(
+		data: INodeExecutionData[][],
+		responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>,
+	): void;
+	getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+	getMode(): WorkflowExecuteMode;
+	getActivationMode(): WorkflowActivateMode;
+	getNode(): INode;
+	getNodeParameter(
+		parameterName: string,
+		fallbackValue?: any,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	getRestApiUrl(): string;
+	getTimezone(): string;
+	getWorkflow(): IWorkflowMetadata;
+	getWorkflowStaticData(type: string): IDataObject;
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+}
+
+
+export type ResourceLocatorModes = 'id' | 'url' | 'list' | string;
+export interface INodeParameterResourceLocator {
+	__rl: true;
+	mode: ResourceLocatorModes;
+	value: NodeParameterValue;
+	cachedResultName?: string;
+	cachedResultUrl?: string;
+	__regex?: string;
+}
+
+export interface ResourceMapperField {
+	id: string;
+	displayName: string;
+	defaultMatch: boolean;
+	canBeUsedToMatch?: boolean;
+	required: boolean;
+	display: boolean;
+	type?: FieldType;
+	removed?: boolean;
+	options?: INodePropertyOptions[];
+	readOnly?: boolean;
+}
+
+export interface IDataObject {
+	[key: string]: GenericValue | IDataObject | GenericValue[] | IDataObject[];
+}
+
+export type ResourceMapperValue = {
+	mappingMode: string;
+	value: { [key: string]: string | number | boolean | null } | null;
+	matchingColumns: string[];
+	schema: ResourceMapperField[];
+	attemptToConvertTypes: boolean;
+	convertFieldsToString: boolean;
+};
+
+export type FilterOperatorType =
+	| 'string'
+	| 'number'
+	| 'boolean'
+	| 'array'
+	| 'object'
+	| 'dateTime'
+	| 'any';
+
+export interface FilterOperatorValue {
+	type: FilterOperatorType;
+	operation: string;
+	rightType?: FilterOperatorType;
+	singleValue?: boolean; // default = false
+}
+
+export type FilterOptionsValue = {
+	caseSensitive: boolean;
+	leftValue: string;
+	typeValidation: 'strict' | 'loose';
+	version: 1 | 2;
+};
+
+export type FilterConditionValue = {
+	id: string;
+	leftValue: NodeParameterValue | NodeParameterValue[];
+	operator: FilterOperatorValue;
+	rightValue: NodeParameterValue | NodeParameterValue[];
+};
+
+export type FilterTypeCombinator = 'and' | 'or';
+
+export type FilterValue = {
+	options: FilterOptionsValue;
+	conditions: FilterConditionValue[];
+	combinator: FilterTypeCombinator;
+};
+
+export type AssignmentValue = {
+	id: string;
+	name: string;
+	value: NodeParameterValue;
+	type?: string;
+};
+
+
+export type AssignmentCollectionValue = {
+	assignments: AssignmentValue[];
+};
+
+export type NodeParameterValueType =
+	// TODO: Later also has to be possible to add multiple ones with the name name. So array has to be possible
+	| NodeParameterValue
+	| INodeParameters
+	| INodeParameterResourceLocator
+	| ResourceMapperValue
+	| FilterValue
+	| AssignmentCollectionValue
+	| NodeParameterValue[]
+	| INodeParameters[]
+	| INodeParameterResourceLocator[]
+	| ResourceMapperValue[];
+
+interface NodeHelperFunctions {
+	copyBinaryFile(filePath: string, fileName: string, mimeType?: string): Promise<IBinaryData>;
+}
+
+export interface IWebhookFunctions {
+	logger: Logger;
+	getBodyData(): IDataObject;
+	getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+	getHeaderData(): object;
+	getMode(): WorkflowExecuteMode;
+	getNode(): INode;
+	getNodeParameter(
+		parameterName: string,
+		fallbackValue?: any,
+		options?: IGetNodeParameterOptions,
+	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | object;
+	evaluateExpression(expression: string, itemIndex?: number): NodeParameterValueType;
+	getNodeWebhookUrl: (name: string) => string | undefined;
+	getParamsData(): object;
+	getQueryData(): object;
+	getRequestObject(): express.Request;
+	getResponseObject(): express.Response;
+	getParentNodes(nodeName: string): NodeTypeAndVersion[];
+	getInstanceId(): string;
+	getTimezone(): string;
+	getWebhookName(): string;
+	getWorkflowStaticData(type: string): IDataObject;
+	getWorkflow(): IWorkflowMetadata;
+	getChildNodes(
+		nodeName: string,
+		options?: { includeNodeParameters?: boolean },
+	): NodeTypeAndVersion[];
+	prepareOutputData(
+		outputData: INodeExecutionData[],
+		outputIndex?: number,
+	): Promise<INodeExecutionData[][]>;
+	nodeHelpers: NodeHelperFunctions;
+	helpers: {
+		httpRequest(
+			requestOptions: IHttpRequestOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		httpRequestWithAuthentication(
+			this: IAllExecuteFunctions,
+			credentialsType: string,
+			requestOptions: IHttpRequestOptions,
+			additionalCredentialOptions?: IAdditionalCredentialOptions,
+		): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+		[key: string]: (...args: any[]) => any; // tslint:disable-line:no-any
+	};
+	addInputData(
+		data: INodeExecutionData[][] | ExecutionError,
+		node?: INode,
+	): { index: number, inputExecutionData: IRunExecutionData };
+	addOutputData(
+		data: INodeExecutionData[][] | ExecutionError,
+		node?: INode,
+	): { outputExecutionData: IRunExecutionData };
+	logAiEvent(event: AiEvent, data?: string): void;
+}
+
+export interface INodeCredentialsDetails {
+	id: string | null;
+	name: string;
+}
+
+export interface INodeCredentials {
+	[key: string]: INodeCredentialsDetails;
+}
+export type OnError = 'continueErrorOutput' | 'continueRegularOutput' | 'stopWorkflow';
+export interface INode {
+	id: string;
+	name: string;
+	typeVersion: number | number[];
+	type: string;
+	position: [number, number];
+	disabled?: boolean;
+	notes?: string;
+	notesInFlow?: boolean;
+	retryOnFail?: boolean;
+	maxTries?: number;
+	waitBetweenTries?: number;
+	alwaysOutputData?: boolean;
+	executeOnce?: boolean;
+	onError?: OnError;
+	continueOnFail?: boolean;
+	parameters: INodeParameters;
+	credentials?: INodeCredentials;
+	webhookId?: string;
+	extendsCredential?: string;
+	rewireOutputLogTo?: NodeConnectionType;
+}
+
+export interface INodes {
+	[key: string]: INode;
+}
+
+export interface IObservableObject {
+	[key: string]: any;
+	__dataChanged: boolean;
+}
+
+export interface IBinaryKeyData {
+	[key: string]: IBinaryData;
+}
+
+export interface INodeExecutionData {
+	[key: string]: IDataObject | IBinaryKeyData | NodeApiError | NodeOperationError | undefined;
+	json: IDataObject;
+	binary?: IBinaryKeyData;
+	error?: NodeApiError | NodeOperationError;
+}
+
+export interface INodeExecuteFunctions {
+	getExecutePollFunctions: IGetExecutePollFunctions;
+	getExecuteTriggerFunctions: IGetExecuteTriggerFunctions;
+	getExecuteFunctions: IGetExecuteFunctions;
+	getExecuteSingleFunctions: IGetExecuteSingleFunctions;
+	getExecuteHookFunctions: IGetExecuteHookFunctions;
+	getExecuteWebhookFunctions: IGetExecuteWebhookFunctions;
+}
+
+// The values a node property can have
+export type NodeParameterValue = string | number | boolean | undefined | null;
+
+export interface INodeParameters {
+	// TODO: Later also has to be possible to add multiple ones with the name name. So array has to be possible
+	[key: string]: NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[];
+}
+
+export type NodePropertyTypes =
+| 'boolean'
+| 'button'
+| 'collection'
+| 'color'
+| 'dateTime'
+| 'fixedCollection'
+| 'hidden'
+| 'json'
+| 'notice'
+| 'multiOptions'
+| 'number'
+| 'options'
+| 'string'
+| 'credentialsSelect'
+| 'resourceLocator'
+| 'curlImport'
+| 'resourceMapper'
+| 'filter'
+| 'assignmentCollection'
+| 'credentials'
+| 'workflowSelector';
+
+export type CodeAutocompleteTypes = 'function' | 'functionItem';
+
+export type EditorTypes = 'code' | 'json' | 'htmlEditor';
+export type CodeNodeEditorLanguage = (typeof CODE_LANGUAGES)[number];
+export type CodeExecutionMode = (typeof CODE_EXECUTION_MODES)[number];
+
+export interface ILoadOptions {
+	routing?: {
+		operations?: IN8nRequestOperations;
+		output?: INodeRequestOutput;
+		request?: IHttpRequestOptionsFromParameters;
+	};
+}
+
+export interface INodePropertyTypeOptions {
+	alwaysOpenEditWindow?: boolean; // Supported by: string
+	codeAutocomplete?: CodeAutocompleteTypes; // Supported by: string
+	editor?: EditorTypes; // Supported by: string
+	loadOptionsDependsOn?: string[]; // Supported by: options
+	loadOptionsMethod?: string; // Supported by: options
+	loadOptions?: ILoadOptions; // Supported by: options
+	maxValue?: number; // Supported by: number
+	minValue?: number; // Supported by: number
+	multipleValues?: boolean; // Supported by: <All>
+	multipleValueButtonText?: string; // Supported when "multipleValues" set to true
+	numberPrecision?: number; // Supported by: number
+	password?: boolean; // Supported by: string
+	rows?: number; // Supported by: string
+	showAlpha?: boolean; // Supported by: color
+	sortable?: boolean; // Supported when "multipleValues" set to true
+	[key: string]: any;
+}
+
+export type DisplayCondition =
+	| { _cnd: { eq: NodeParameterValue } }
+	| { _cnd: { not: NodeParameterValue } }
+	| { _cnd: { gte: number | string } }
+	| { _cnd: { lte: number | string } }
+	| { _cnd: { gt: number | string } }
+	| { _cnd: { lt: number | string } }
+	| { _cnd: { between: { from: number | string; to: number | string } } }
+	| { _cnd: { startsWith: string } }
+	| { _cnd: { endsWith: string } }
+	| { _cnd: { includes: string } }
+	| { _cnd: { regex: string } }
+	| { _cnd: { exists: true } };
+
+
+export interface IDisplayOptions {
+	hide?: {
+		[key: string]: Array<NodeParameterValue | DisplayCondition> | NodeParameterValue[] | undefined;
+	};
+	show?: {
+		[key: string]: Array<NodeParameterValue | DisplayCondition> | NodeParameterValue[] | undefined;
+	};
+}
+
+export type FieldTypeMap = {
+	// eslint-disable-next-line id-denylist
+	boolean: boolean;
+	// eslint-disable-next-line id-denylist
+	number: number;
+	// eslint-disable-next-line id-denylist
+	string: string;
+	'string-alphanumeric': string;
+	dateTime: string;
+	time: string;
+	array: unknown[];
+	object: object;
+	options: any;
+	url: string;
+	jwt: string;
+	'form-fields': FormFieldsParameter;
+};
+
+export type ValidationResult<T extends FieldType = FieldType> =
+	| { valid: false; errorMessage: string }
+	| {
+		valid: true;
+		newValue?: FieldTypeMap[T];
+	};
+
+export type FieldType = keyof FieldTypeMap;
+
+export namespace MultiPartFormData {
+	export interface File {
+		filepath: string;
+		mimetype?: string;
+		originalFilename?: string;
+		newFilename: string;
+		size?: number;
+	}
+
+	export type Request = express.Request<
+		{},
+		{},
+		{
+			data: Record<string, string | string[]>;
+			files: Record<string, File | File[]>;
+		}
+	>;
+}
+
+export interface IVersionedNodeType {
+	nodeVersions: {
+		[key: number]: INodeType;
+	};
+	currentVersion: number;
+	description: INodeTypeBaseDescription;
+	getNodeType: (version?: number) => INodeType;
+}
+
+export interface INodePropertyModeValidation {
+	type: string;
+	properties: {};
+}
+
+export interface INodePropertyValueExtractorFunction {
+	(
+		this: IExecuteSingleFunctions,
+		value: string | NodeParameterValue,
+	): Promise<string | NodeParameterValue> | (string | NodeParameterValue);
+}
+
+export interface INodePropertyValueExtractorBase {
+	type: string;
+}
+
+export interface INodePropertyValueExtractorRegex extends INodePropertyValueExtractorBase {
+	type: 'regex';
+	regex: string | RegExp;
+}
+
+export type INodePropertyValueExtractor = INodePropertyValueExtractorRegex;
+
+export interface INodePropertyModeTypeOptions {
+	searchListMethod?: string; // Supported by: options
+	searchFilterRequired?: boolean;
+	searchable?: boolean;
+}
+
+
+export interface INodePropertyMode {
+	displayName: string;
+	name: string;
+	type: 'string' | 'list';
+	hint?: string;
+	validation?: Array<
+		INodePropertyModeValidation | { (this: IExecuteSingleFunctions, value: string): void }
+	>;
+	placeholder?: string;
+	url?: string;
+	extractValue?: INodePropertyValueExtractor;
+	initType?: string;
+	entryTypes?: {
+		[name: string]: {
+			selectable?: boolean;
+			hidden?: boolean;
+			queryable?: boolean;
+			data?: {
+				request?: IHttpRequestOptions;
+				output?: INodeRequestOutput;
+			};
+		};
+	};
+	search?: INodePropertyRouting;
+	typeOptions?: INodePropertyModeTypeOptions;
+}
+
+export interface INodeProperties {
+	displayName: string;
+	name: string;
+	type: NodePropertyTypes;
+	typeOptions?: INodePropertyTypeOptions;
+	default: NodeParameterValue | INodeParameters | INodeParameters[] | NodeParameterValue[];
+	description?: string;
+	hint?: string;
+	displayOptions?: IDisplayOptions;
+	options?: Array<INodePropertyOptions | INodeProperties | INodePropertyCollection>;
+	placeholder?: string;
+	isNodeSetting?: boolean;
+	noDataExpression?: boolean;
+	required?: boolean;
+	routing?: INodePropertyRouting;
+	modes?: INodePropertyMode[];
+	validateType?: FieldType;
+	ignoreValidationDuringExecution?: boolean;
+	disabledOptions?: {
+		show?: {
+			[key: string]: Array<NodeParameterValue | DisplayCondition> | NodeParameterValue[] | undefined;
+		};
+	};
+}
+export interface INodePropertyOptions {
+	name: string;
+	value: string | number | boolean;
+	action?: string;
+	description?: string;
+	routing?: INodePropertyRouting;
+	outputConnectionType?: NodeConnectionType;
+}
+
+export interface INodePropertyCollection {
+	displayName: string;
+	name: string;
+	values: INodeProperties[];
+}
+
+export interface IParameterDependencies {
+	[key: string]: string[];
+}
+
+export interface IPollResponse {
+	closeFunction?: () => Promise<void>;
+}
+
+export interface ITriggerResponse {
+	closeFunction?: () => Promise<void>;
+	// To manually trigger the run
+	manualTriggerFunction?: () => Promise<void>;
+	// Gets added automatically at manual workflow runs resolves with
+	// the first emitted data
+	manualTriggerResponse?: Promise<INodeExecutionData[][]>;
+}
+
+export interface SupplyData {
+	metadata?: IDataObject;
+	response: unknown;
+	closeFunction?: () => Promise<void>;
+}
+
+namespace ExecuteFunctions {
+	namespace StringReturning {
+		export type NodeParameter =
+			| 'binaryProperty'
+			| 'binaryPropertyName'
+			| 'binaryPropertyOutput'
+			| 'dataPropertyName'
+			| 'dataBinaryProperty'
+			| 'resource'
+			| 'operation'
+			| 'filePath'
+			| 'encodingType';
+	}
+
+	namespace NumberReturning {
+		export type NodeParameter = 'limit';
+	}
+
+	namespace BooleanReturning {
+		export type NodeParameter =
+			| 'binaryData'
+			| 'download'
+			| 'jsonParameters'
+			| 'returnAll'
+			| 'rawData'
+			| 'resolveData';
+	}
+
+	namespace RecordReturning {
+		export type NodeParameter = 'additionalFields' | 'filters' | 'options' | 'updateFields';
+	}
+
+	export type GetNodeParameterFn = {
+		// @TECH_DEBT: Refactor to remove this barely used overload - N8N-5632
+		getNodeParameter<T extends { resource: string }>(
+			parameterName: 'resource',
+			itemIndex?: number,
+		): T['resource'];
+
+		getNodeParameter(
+			parameterName: StringReturning.NodeParameter,
+			itemIndex: number,
+			fallbackValue?: string,
+			options?: IGetNodeParameterOptions,
+		): string;
+		getNodeParameter(
+			parameterName: RecordReturning.NodeParameter,
+			itemIndex: number,
+			fallbackValue?: IDataObject,
+			options?: IGetNodeParameterOptions,
+		): IDataObject;
+		getNodeParameter(
+			parameterName: BooleanReturning.NodeParameter,
+			itemIndex: number,
+			fallbackValue?: boolean,
+			options?: IGetNodeParameterOptions,
+		): boolean;
+		getNodeParameter(
+			parameterName: NumberReturning.NodeParameter,
+			itemIndex: number,
+			fallbackValue?: number,
+			options?: IGetNodeParameterOptions,
+		): number;
+		getNodeParameter(
+			parameterName: string,
+			itemIndex: number,
+			fallbackValue?: any,
+			options?: IGetNodeParameterOptions,
+		): NodeParameterValueType | object;
+	};
+}
+
+export interface INodeListSearchItems extends INodePropertyOptions {
+	icon?: string;
+	url?: string;
+}
+
+export interface INodeListSearchResult {
+	results: INodeListSearchItems[];
+	paginationToken?: unknown;
+}
+
+export type IWorkflowNodeContext = ExecuteFunctions.GetNodeParameterFn &
+	Pick<FunctionsBase, 'getNode' | 'getWorkflow'>;
+
+export interface ILocalLoadOptionsFunctions {
+	getWorkflowNodeContext(nodeType: string): Promise<IWorkflowNodeContext | null>;
+}
+
+export type LogLevel = (typeof LOG_LEVELS)[number];
+export type LogMetadata = {
+	[key: string]: unknown;
+	scopes?: unknown[];
+	file?: string;
+	function?: string;
+};
+export type Logger = Record<
+	Exclude<LogLevel, 'silent'>,
+	(message: string, metadata?: LogMetadata) => void
+>;
+
+export interface FunctionsBase {
+	logger: Logger;
+	getCredentials<T extends object = ICredentialDataDecryptedObject>(
+		type: string,
+		itemIndex?: number,
+	): Promise<T>;
+	getCredentialsProperties(type: string): INodeProperties[];
+	getExecutionId(): string;
+	getNode(): INode;
+	getWorkflow(): IWorkflowMetadata;
+	getWorkflowStaticData(type: string): IDataObject;
+	getTimezone(): string;
+	getRestApiUrl(): string;
+	getInstanceBaseUrl(): string;
+	getInstanceId(): string;
+	getChildNodes(
+		nodeName: string,
+		options?: { includeNodeParameters?: boolean },
+	): NodeTypeAndVersion[];
+	getParentNodes(nodeName: string): NodeTypeAndVersion[];
+	getKnownNodeTypes(): IDataObject;
+	getMode?: () => WorkflowExecuteMode;
+	getActivationMode?: () => WorkflowActivateMode;
+
+	/** @deprecated */
+	prepareOutputData(outputData: INodeExecutionData[]): Promise<INodeExecutionData[][]>;
+}
+
+export interface ResourceMapperFields {
+	fields: ResourceMapperField[];
+	emptyFieldsNotice?: string;
+}
+
+export interface INodeType {
+	description: INodeTypeDescription;
+	supplyData?(this: ISupplyDataFunctions | IWebhookFunctions, itemIndex: number): Promise<SupplyData>;
+	execute?(this: IExecuteFunctions): Promise<INodeExecutionData[][] | null>;
+	executeSingle?(this: IExecuteSingleFunctions): Promise<INodeExecutionData>;
+	poll?(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+	trigger?(this: ITriggerFunctions): Promise<ITriggerResponse | undefined>;
+	webhook?(this: IWebhookFunctions, workflow?: Workflow): Promise<IWebhookResponseData>;
+	hooks?: {
+		[key: string]: (this: IHookFunctions) => Promise<boolean>;
+	};
+	methods?: {
+		loadOptions?: {
+			[key: string]: (this: ILoadOptionsFunctions) => Promise<INodePropertyOptions[]>;
+		};
+		listSearch?: {
+			[key: string]: (
+				this: ILoadOptionsFunctions,
+				filter?: string,
+				paginationToken?: string,
+			) => Promise<INodeListSearchResult>;
+		};
+		credentialTest?: {
+			// Contains a group of functins that test credentials.
+			[functionName: string]: ICredentialTestFunction;
+		};
+		resourceMapping?: {
+			[functionName: string]: (this: ILoadOptionsFunctions) => Promise<ResourceMapperFields>;
+		};
+		localResourceMapping?: {
+			[functionName: string]: (this: ILocalLoadOptionsFunctions) => Promise<ResourceMapperFields>;
+		};
+		actionHandler?: {
+			[functionName: string]: (
+				this: ILoadOptionsFunctions,
+				payload: IDataObject | string | undefined,
+			) => Promise<NodeParameterValueType>;
+		};
+	};
+	webhookMethods?: {
+		[key: string]: IWebhookSetupMethods;
+	};
+}
+
+export interface INodeVersionedType {
+	nodeVersions: {
+		[key: number]: INodeType;
+	};
+	currentVersion: number;
+	description: INodeTypeBaseDescription;
+	getNodeType: (version?: number) => INodeType;
+}
+export interface INodeCredentialTestResult {
+	status: 'OK' | 'Error';
+	message: string;
+}
+
+export interface INodeCredentialTestRequest {
+	nodeToTestWith?: string; // node name i.e. slack
+	credentials: ICredentialsDecrypted;
+}
+
+export type WebhookSetupMethodNames = 'checkExists' | 'create' | 'delete';
+
+export interface IWebhookSetupMethods {
+	[key: string]: ((this: IHookFunctions) => Promise<boolean>) | undefined;
+	checkExists?: (this: IHookFunctions) => Promise<boolean>;
+	create?: (this: IHookFunctions) => Promise<boolean>;
+	delete?: (this: IHookFunctions) => Promise<boolean>;
+}
+
+export interface INodeCredentialDescription {
+	name: string;
+	required?: boolean;
+	displayOptions?: IDisplayOptions;
+	testedBy?: ICredentialTestRequest | string; // Name of a function inside `loadOptions.credentialTest`
+}
+
+export type FormFieldsParameter = Array<{
+	fieldLabel: string;
+	elementName?: string;
+	fieldType?: string;
+	requiredField?: boolean;
+	fieldOptions?: { values: Array<{ option: string }> };
+	multiselect?: boolean;
+	multipleFiles?: boolean;
+	acceptFileTypes?: string;
+	formatDate?: string;
+	html?: string;
+	placeholder?: string;
+	fieldName?: string;
+	fieldValue?: string;
+}>;
+
+export const NodeConnectionTypes = {
+	AiAgent: 'ai_agent',
+	AiChain: 'ai_chain',
+	AiDocument: 'ai_document',
+	AiEmbedding: 'ai_embedding',
+	AiLanguageModel: 'ai_languageModel',
+	AiMemory: 'ai_memory',
+	AiOutputParser: 'ai_outputParser',
+	AiRetriever: 'ai_retriever',
+	AiTextSplitter: 'ai_textSplitter',
+	AiTool: 'ai_tool',
+	AiVectorStore: 'ai_vectorStore',
+	Main: 'main',
+} as const;
+
+export type NodeConnectionType = (typeof NodeConnectionTypes)[keyof typeof NodeConnectionTypes];
+
+export type INodeIssueTypes = 'credentials' | 'execution' | 'parameters' | 'typeUnknown';
+
+export interface INodeIssueObjectProperty {
+	[key: string]: string[];
+} 
+
+export interface INodeIssueData {
+	node: string;
+	type: INodeIssueTypes;
+	value: boolean | string | string[] | INodeIssueObjectProperty;
+}
+
+export interface INodeIssues {
+	execution?: boolean;
+	credentials?: INodeIssueObjectProperty;
+	parameters?: INodeIssueObjectProperty;
+	typeUnknown?: boolean;
+	[key: string]: undefined | boolean | INodeIssueObjectProperty;
+}
+
+export interface IWorfklowIssues {
+	[key: string]: INodeIssues;
+}
+
+export type ThemeIconColor =
+	| 'gray'
+	| 'black'
+	| 'blue'
+	| 'light-blue'
+	| 'dark-blue'
+	| 'orange'
+	| 'orange-red'
+	| 'pink-red'
+	| 'red'
+	| 'light-green'
+	| 'green'
+	| 'dark-green'
+	| 'azure'
+	| 'purple'
+	| 'crimson';
+
+export type Themed<T> = T | { light: T; dark: T };
+
+export interface INodeTypeBaseDescription {
+	displayName: string;
+	name: string;
+	icon?: string | Icon;
+	iconColor?: ThemeIconColor;
+	iconUrl?: Themed<string>;
+	group: string[];
+	description: string;
+	documentationUrl?: string;
+	subtitle?: string;
+	defaultVersion?: number;
+	codex?: CodexData;
+}
+
+export interface INodePropertyRouting {
+	operations?: IN8nRequestOperations; // Should be changed, does not sound right
+	output?: INodeRequestOutput;
+	request?: IHttpRequestOptionsFromParameters;
+	send?: INodeRequestSend;
+}
+
+export interface IPostReceiveBase {
+	type: string;
+	enabled?: boolean | string;
+	properties: {
+		[key: string]: string | number | boolean | IDataObject;
+	};
+	errorMessage?: string;
+}
+
+export interface IPostReceiveFilter extends IPostReceiveBase {
+	type: 'filter';
+	properties: {
+		pass: boolean | string;
+	};
+}
+
+export interface IPostReceiveLimit extends IPostReceiveBase {
+	type: 'limit';
+	properties: {
+		maxResults: number | string;
+	};
+}
+
+export type PostReceiveAction =
+	| ((
+			this: IExecuteSingleFunctions,
+			items: INodeExecutionData[],
+			response: IN8nHttpFullResponse,
+	  ) => Promise<INodeExecutionData[]>)
+	| IPostReceiveBinaryData
+	| IPostReceiveFilter
+	| IPostReceiveLimit
+	| IPostReceiveRootProperty
+	| IPostReceiveSet
+	| IPostReceiveSetKeyValue
+	| IPostReceiveSort;
+
+export type PreSendAction = (
+	this: IExecuteSingleFunctions,
+	requestOptions: IHttpRequestOptions,
+) => Promise<IHttpRequestOptions>;
+
+export interface INodeRequestOutput {
+	maxResults?: number | string;
+	postReceive?: PostReceiveAction[];
+}
+
+export interface INodeRequestSend {
+	preSend?: PreSendAction[];
+	paginate?: boolean | string; // Where should this life?
+	property?: string; // Maybe: propertyName, destinationProperty?
+	propertyInDotNotation?: boolean; // Enabled by default
+	type?: 'body' | 'query';
+	value?: string;
+}
+
+export interface IPostReceiveBinaryData extends IPostReceiveBase {
+	type: 'binaryData';
+	properties: {
+		destinationProperty: string;
+	};
+}
+
+export interface IPostReceiveRootProperty extends IPostReceiveBase {
+	type: 'rootProperty';
+	properties: {
+		property: string;
+	};
+}
+
+export interface IPostReceiveSet extends IPostReceiveBase {
+	type: 'set';
+	properties: {
+		value: string;
+	};
+}
+
+export interface IPostReceiveSetKeyValue extends IPostReceiveBase {
+	type: 'setKeyValue';
+	properties: {
+		[key: string]: string | number;
+	};
+}
+
+export interface IPostReceiveSort extends IPostReceiveBase {
+	type: 'sort';
+	properties: {
+		key: string;
+	};
+}
+
+export interface IHttpRequestOptionsFromParameters extends Partial<IHttpRequestOptions> {
+	url?: string;
+}
+
+export interface IRequestOptionsFromParameters {
+	maxResults?: number | string;
+	options: IHttpRequestOptionsFromParameters;
+	paginate?: boolean | string;
+	preSend: PreSendAction[];
+	postReceive: Array<{
+		data: {
+			parameterValue: string | IDataObject | undefined;
+		};
+		actions: PostReceiveAction[];
+	}>;
+	requestOperations?: IN8nRequestOperations;
+}
+
+export type TriggerPanelDefinition = {
+	hideContent?: boolean | string;
+	header?: string;
+	executionsHelp?: string | { active: string; inactive: string };
+	activationHint?: string | { active: string; inactive: string };
+};
+
+
+export type ExpressionString = `={{${string}}}`;
+
+export interface INodeTypeDescription extends INodeTypeBaseDescription {
+	version: number | number[];
+	defaults: INodeParameters;
+	triggerPanel?: TriggerPanelDefinition | boolean;
+	eventTriggerDescription?: string;
+	activationMessage?: string;
+	inputs: Array<NodeConnectionType | INodeInputConfiguration>;
+	inputNames?: string[];
+	outputs: Array<NodeConnectionType | INodeOutputConfiguration>;
+	outputNames?: string[];
+	properties: INodeProperties[];
+	credentials?: INodeCredentialDescription[];
+	maxNodes?: number; // How many nodes of that type can be created in a workflow
+	polling?: boolean;
+	requestDefaults?: IHttpRequestOptionsFromParameters;
+	requestOperations?: IN8nRequestOperations;
+	hooks?: {
+		[key: string]: INodeHookDescription[] | undefined;
+		activate?: INodeHookDescription[];
+		deactivate?: INodeHookDescription[];
+	};
+	webhooks?: IWebhookDescription[];
+	translation?: { [key: string]: object };
+	supportsCORS?: true | undefined;
+	__loadOptionsMethods?: string[]; // only for validation during build
+}
+
+export interface INodeHookDescription {
+	method: string;
+}
+
+export interface IWebhookData {
+	httpMethod: WebhookHttpMethod;
+	node: string;
+	path: string;
+	webhookDescription: IWebhookDescription;
+	workflowId: string;
+	workflowExecuteAdditionalData: IWorkflowExecuteAdditionalData;
+	webhookId?: string;
+}
+
+export interface IWebhookDescription {
+	[key: string]: WebhookHttpMethod | WebhookResponseMode | boolean | string | undefined;
+	httpMethod: WebhookHttpMethod | string;
+	isFullPath?: boolean;
+	name: string;
+	path: string;
+	responseBinaryPropertyName?: string;
+	responseContentType?: string;
+	responsePropertyName?: string;
+	responseMode?: WebhookResponseMode | string;
+	responseData?: WebhookResponseData | string;
+	restartWebhook?: boolean;
+}
+
+export interface IWorkflowDataProxyData {
+	[key: string]: any;
+	$binary: any;
+	$data: any;
+	$env: any;
+	$evaluateExpression: any;
+	$item: any;
+	$items: any;
+	$json: any;
+	$node: any;
+	$parameter: any;
+	$position: any;
+	$workflow: any;
+	$: any;
+	$input: any;
+	$thisItem: any;
+	$thisRunIndex: number;
+	$thisItemIndex: number;
+	$now: any;
+	$today: any;
+}
+
+export type IWorkflowDataProxyAdditionalKeys = IDataObject;
+
+export interface IWorkflowMetadata {
+	id?: number | string;
+	name?: string;
+	active: boolean;
+}
+
+export type WebhookHttpMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'OPTIONS';
+
+export interface IWebhookResponseData {
+	workflowData?: INodeExecutionData[][];
+	webhookResponse?: any;
+	noWebhookResponse?: boolean;
+}
+
+export type WebhookResponseData = 'allEntries' | 'firstEntryJson' | 'firstEntryBinary' | 'noData';
+export type WebhookResponseMode = 'onReceived' | 'lastNode';
+
+export interface INodeTypes {
+	nodeTypes: INodeTypeData;
+	init(nodeTypes?: INodeTypeData): Promise<void>;
+	getAll(): Array<INodeType | INodeVersionedType>;
+	getByNameAndVersion(nodeType: string, version?: number | number[]): INodeType | undefined;
+}
+
+export interface ICredentialTypeData {
+	[key: string]: {
+		type: ICredentialType;
+		sourcePath: string;
+	};
+}
+
+export interface INodeTypeData {
+	[key: string]: {
+		type: INodeType | INodeVersionedType;
+		sourcePath: string;
+	};
+}
+
+export interface IRun {
+	data: IRunExecutionData;
+	finished?: boolean;
+	mode: WorkflowExecuteMode;
+	waitTill?: Date;
+	startedAt: Date;
+	stoppedAt?: Date;
+}
+
+
+export type EnsureTypeOptions = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'json';
+export interface IGetNodeParameterOptions {
+	contextNode?: INode;
+	// make sure that returned value would be of specified type, converts it if needed
+	ensureType?: EnsureTypeOptions;
+	// extract value from regex, works only when parameter type is resourceLocator
+	extractValue?: boolean;
+	// get raw value of parameter with unresolved expressions
+	rawExpressions?: boolean;
+}
+
+// Contains all the data which is needed to execute a workflow and so also to
+// start restart it again after it did fail.
+// The RunData, ExecuteData and WaitForExecution contain often the same data.
+export interface IRunExecutionData {
+	startData?: {
+		destinationNode?: string;
+		runNodeFilter?: string[];
+	};
+	resultData: {
+		error?: ExecutionError;
+		runData: IRunData;
+		lastNodeExecuted?: string;
+	};
+	executionData?: {
+		contextData: IExecuteContextData;
+		nodeExecutionStack: IExecuteData[];
+		waitingExecution: IWaitingForExecution;
+	};
+	waitTill?: Date;
+}
+
+export interface IRunData {
+	// node-name: result-data
+	[key: string]: ITaskData[];
+}
+
+// The data that gets returned when a node runs
+export interface ITaskData {
+	startTime: number;
+	executionTime: number;
+	data?: ITaskDataConnections;
+	error?: ExecutionError;
+}
+
+// The data for al the different kind of connectons (like main) and all the indexes
+export interface ITaskDataConnections {
+	// Key for each input type and because there can be multiple inputs of the same type it is an array
+	// null is also allowed because if we still need data for a later while executing the workflow set teompoary to null
+	// the nodes get as input TaskDataConnections which is identical to this one except that no null is allowed.
+	[key: string]: Array<INodeExecutionData[] | null>;
+}
+
+// Keeps data while workflow gets executed and allows when provided to restart execution
+export interface IWaitingForExecution {
+	// Node name
+	[key: string]: {
+		// Run index
+		[key: number]: ITaskDataConnections;
+	};
+}
+
+export interface IWorkflowBase {
+	id?: number | string | any;
+	name: string;
+	active: boolean;
+	createdAt: Date;
+	updatedAt: Date;
+	nodes: INode[];
+	connections: IConnections;
+	settings?: IWorkflowSettings;
+	staticData?: IDataObject;
+}
+
+export interface IWorkflowCredentials {
+	[credentialType: string]: {
+		[id: string]: ICredentialsEncrypted;
+	};
+}
+
+export interface IWorkflowExecuteHooks {
+	[key: string]: Array<(...args: any[]) => Promise<void>> | undefined;
+	nodeExecuteAfter?: Array<
+		(nodeName: string, data: ITaskData, executionData: IRunExecutionData) => Promise<void>
+	>;
+	nodeExecuteBefore?: Array<(nodeName: string) => Promise<void>>;
+	workflowExecuteAfter?: Array<(data: IRun, newStaticData: IDataObject) => Promise<void>>;
+	workflowExecuteBefore?: Array<(workflow: Workflow, data: IRunExecutionData) => Promise<void>>;
+	sendResponse?: Array<(response: IExecuteResponsePromiseData) => Promise<void>>;
+}
+
+export interface IWorkflowExecuteAdditionalData {
+	credentialsHelper: ICredentialsHelper;
+	encryptionKey: string;
+	executeWorkflow: (
+		workflowInfo: IExecuteWorkflowInfo,
+		additionalData: IWorkflowExecuteAdditionalData,
+		inputData?: INodeExecutionData[],
+		parentExecutionId?: string,
+		loadedWorkflowData?: IWorkflowBase,
+		loadedRunData?: any,
+	) => Promise<any>;
+	// hooks?: IWorkflowExecuteHooks;
+	executionId?: string;
+	hooks?: WorkflowHooks;
+	httpResponse?: express.Response;
+	httpRequest?: express.Request;
+	restApiUrl: string;
+	sendMessageToUI?: (source: string, message: any) => void;
+	timezone: string;
+	webhookBaseUrl: string;
+	webhookWaitingBaseUrl: string;
+	webhookTestBaseUrl: string;
+	currentNodeParameters?: INodeParameters;
+	executionTimeoutTimestamp?: number;
+	userId: string;
+}
+
+export type WorkflowExecuteMode =
+	| 'cli'
+	| 'error'
+	| 'integrated'
+	| 'internal'
+	| 'manual'
+	| 'retry'
+	| 'trigger'
+	| 'webhook';
+export type WorkflowActivateMode = 'init' | 'create' | 'update' | 'activate' | 'manual';
+
+export interface IWorkflowHooksOptionalParameters {
+	parentProcessMode?: string;
+	retryOf?: string;
+	sessionId?: string;
+}
+
+export interface IWorkflowSettings {
+	[key: string]: IDataObject | string | number | boolean | undefined;
+}
+
+export type LogTypes = 'debug' | 'verbose' | 'info' | 'warn' | 'error';
+
+export interface ILogger {
+	log: (type: LogTypes, message: string, meta?: object) => void;
+	debug: (message: string, meta?: object) => void;
+	verbose: (message: string, meta?: object) => void;
+	info: (message: string, meta?: object) => void;
+	warn: (message: string, meta?: object) => void;
+	error: (message: string, meta?: object) => void;
+}
+
+export interface IStatusCodeMessages {
+	[key: string]: string;
+}
+
+export interface INodeInputFilter {
+	// TODO: Later add more filter options like categories, subcatogries,
+	//       regex, allow to exclude certain nodes, ... ?
+	//       Potentially change totally after alpha/beta. Is not a breaking change after all.
+	nodes: string[]; // Allowed nodes
+}
+
+export interface INodeInputConfiguration {
+	category?: string;
+	displayName?: string;
+	required?: boolean;
+	type: NodeConnectionType;
+	filter?: INodeInputFilter;
+	maxConnections?: number;
+}
+
+export interface INodeOutputConfiguration {
+	category?: 'error';
+	displayName?: string;
+	maxConnections?: number;
+	required?: boolean;
+	type: NodeConnectionType;
+}
+
+export type NodeLoadingDetails = LoadingDetails;
+
+export type LoadingDetails = {
+	className: string;
+	sourcePath: string;
+};
+
+export type CredentialLoadingDetails = LoadingDetails & {
+	supportedNodes?: string[];
+	extends?: string[];
+};
+
+export type DocumentationLink = {
+	url: string;
+};
+
+export type KnownNodesAndCredentials = {
+	nodes: Record<string, NodeLoadingDetails>;
+	credentials: Record<string, CredentialLoadingDetails>;
+};
+
+export type CodexData = {
+	categories?: string[];
+	subcategories?: { [category: string]: string[] };
+	resources?: {
+		credentialDocumentation?: DocumentationLink[];
+		primaryDocumentation?: DocumentationLink[];
+	};
+	alias?: string[];
+};
+
+export type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
+
+export type JsonObject = { [key: string]: JsonValue };
+
+export type AllEntities<M> = M extends { [key: string]: string } ? Entity<M, keyof M> : never;
+
+export type Entity<M, K> = K extends keyof M ? { resource: K; operation: M[K] } : never;
+
+export type PropertiesOf<M extends { resource: string; operation: string }> = Array<
+	Omit<INodeProperties, 'displayOptions'> & {
+		displayOptions?: {
+			[key in 'show' | 'hide']?: {
+				resource?: Array<M['resource']>;
+				operation?: Array<M['operation']>;
+				[otherKey: string]: NodeParameterValue[] | undefined;
+			};
+		};
+	}
+>;
+
+// Telemetry
+
+export interface INodesGraph {
+	node_types: string[];
+	node_connections: IDataObject[];
+	nodes: INodesGraphNode;
+}
+
+export interface INodesGraphNode {
+	[key: string]: INodeGraphItem;
+}
+
+export interface INodeGraphItem {
+	type: string;
+	resource?: string;
+	operation?: string;
+	domain?: string;
+	position: [number, number];
+	mode?: string;
+}
+
+export interface INodeNameIndex {
+	[name: string]: string;
+}
+
+export interface INodesGraphResult {
+	nodeGraph: INodesGraph;
+	nameIndices: INodeNameIndex;
+}
+
+export interface ITelemetryClientConfig {
+	url: string;
+	key: string;
+}
+
+export interface ITelemetrySettings {
+	enabled: boolean;
+	config?: ITelemetryClientConfig;
+}
+export interface ISourceData {
+	previousNode: string;
+	previousNodeOutput?: number; // If undefined "0" gets used
+	previousNodeRun?: number; // If undefined "0" gets used
+}
+export interface IPairedItemData {
+	item: number;
+	input?: number; // If undefined "0" gets used
+	sourceOverwrite?: ISourceData;
+}
+
+export type CloseFunction = () => Promise<void>;
+
+export interface SupplyData {
+	metadata?: IDataObject;
+	response: unknown;
+	closeFunction?: CloseFunction;
+}
+
+type FunctionsBaseWithRequiredKeys<Keys extends keyof FunctionsBase> = FunctionsBase & {
+	[K in Keys]: NonNullable<FunctionsBase[K]>;
+};
+
+export type AiEvent =
+	| 'ai-messages-retrieved-from-memory'
+	| 'ai-message-added-to-memory'
+	| 'ai-output-parsed'
+	| 'ai-documents-retrieved'
+	| 'ai-document-embedded'
+	| 'ai-query-embedded'
+	| 'ai-document-processed'
+	| 'ai-text-split'
+	| 'ai-tool-called'
+	| 'ai-vector-store-searched'
+	| 'ai-llm-generated-output'
+	| 'ai-llm-errored'
+	| 'ai-vector-store-populated'
+	| 'ai-vector-store-updated';