@fsai-flow/workflow 0.0.2 → 0.1.0

package/dist/src/lib/Interfaces.d.ts

@@ -0,0 +1,1623 @@
+import type { URLSearchParams } from "node:url";
+import type * as express from "express";
+import type * as FormData from "form-data";
+import type { CODE_EXECUTION_MODES, CODE_LANGUAGES, LOG_LEVELS } from "./Constants";
+import type { IDeferredPromise } from "./DeferredPromise";
+import type { NodeApiError, NodeOperationError } from "./NodeErrors";
+import type { Workflow } from "./Workflow";
+import type { WorkflowOperationError } from "./WorkflowErrors";
+import type { WorkflowHooks } from "./WorkflowHooks";
+/**
+ * Replacement types for the deprecated `request` / `request-promise-native` packages.
+ * These cover the subset of options that was actually referenced in this codebase.
+ */
+/** Mirrors `request.CoreOptions` – the common HTTP-request option bag. */
+export interface IRequestCoreOptions {
+    baseUrl?: string;
+    jar?: boolean | object;
+    formData?: Record<string, unknown>;
+    form?: Record<string, unknown> | string;
+    auth?: {
+        user?: string;
+        username?: string;
+        password?: string;
+        bearer?: string;
+        sendImmediately?: boolean;
+    };
+    oauth?: Record<string, unknown>;
+    qs?: Record<string, unknown>;
+    qsStringifyOptions?: Record<string, unknown>;
+    qsParseOptions?: Record<string, unknown>;
+    json?: unknown;
+    multipart?: Array<{
+        body: unknown;
+        [key: string]: unknown;
+    }>;
+    agent?: unknown;
+    agentOptions?: Record<string, unknown>;
+    forever?: boolean;
+    host?: string;
+    port?: number;
+    method?: string;
+    headers?: Record<string, unknown>;
+    body?: unknown;
+    followRedirect?: boolean | ((response: unknown) => boolean);
+    followAllRedirects?: boolean;
+    maxRedirects?: number;
+    encoding?: string | null;
+    timeout?: number;
+    proxy?: unknown;
+    strictSSL?: boolean;
+    rejectUnauthorized?: boolean;
+    gzip?: boolean;
+    useQuerystring?: boolean;
+    [key: string]: unknown;
+}
+/** Equivalent to `request.OptionsWithUri`. */
+export type OptionsWithUri = IRequestCoreOptions & {
+    uri: string;
+};
+/** Equivalent to `request.OptionsWithUrl`. */
+export type OptionsWithUrl = IRequestCoreOptions & {
+    url: string;
+};
+/** Equivalent to `request-promise-native.RequestPromiseOptions`. */
+export interface RequestPromiseOptions extends IRequestCoreOptions {
+    simple?: boolean;
+    resolveWithFullResponse?: boolean;
+    transform?: (body: unknown, response: unknown, resolveWithFullResponse?: boolean) => unknown;
+    transform2xxOnly?: boolean;
+}
+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 {
+    node: string;
+    type: string;
+    index: number;
+}
+export type ExecutionError = WorkflowOperationError | NodeOperationError | NodeApiError;
+export interface IGetCredentials {
+    get(type: string, id: string | null): Promise<ICredentialsEncrypted>;
+}
+export declare abstract class ICredentials {
+    id?: string;
+    name: string;
+    type: string;
+    data: string | undefined;
+    nodesAccess: ICredentialNodeAccess[];
+    constructor(nodeCredentials: INodeCredentialsDetails, type: string, nodesAccess: ICredentialNodeAccess[], data?: string);
+    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;
+}
+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;
+}
+export interface IRequestOptionsSimplified {
+    auth?: {
+        username: string;
+        password: string;
+    };
+    body: IDataObject;
+    headers: IDataObject;
+    qs: IDataObject;
+}
+export declare abstract class ICredentialsHelper {
+    encryptionKey: string;
+    constructor(encryptionKey: string);
+    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 declare 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;
+}
+export interface ICredentialData {
+    id?: string;
+    name: string;
+    data: string;
+    nodesAccess: ICredentialNodeAccess[];
+}
+export type CredentialInformation = string | number | boolean | IDataObject;
+export interface ICredentialDataDecryptedObject {
+    [key: string]: CredentialInformation;
+}
+export type NodeInputConnections = IConnection[][];
+export interface INodeConnections {
+    [key: string]: NodeInputConnections;
+}
+export interface IConnections {
+    [key: string]: INodeConnections;
+}
+export type GenericValue = string | object | number | boolean | undefined | null;
+export type IExecuteResponsePromiseData = IDataObject | IN8nHttpFullResponse;
+export interface INodeTypeNameVersion {
+    name: string;
+    version: number;
+}
+export type IGetExecutePollFunctions = (workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode) => IPollFunctions;
+export type IGetExecuteTriggerFunctions = (workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode) => ITriggerFunctions;
+export type IGetExecuteFunctions = (workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, nodeTypeData: INodeType, closeFunctions: CloseFunction[]) => IExecuteFunctions;
+export type IGetExecuteSingleFunctions = (workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, connectionInputData: INodeExecutionData[], inputData: ITaskDataConnections, node: INode, itemIndex: number, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode) => IExecuteSingleFunctions;
+export type IGetExecuteHookFunctions = (workflow: Workflow, node: INode, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, activation: WorkflowActivateMode, isTest?: boolean, webhookData?: IWebhookData) => IHookFunctions;
+export type 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]: unknown;
+};
+export interface IExecuteContextData {
+    [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;
+        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>;
+declare namespace RecordReturning {
+    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<unknown>;
+    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: string, itemIndex: number, fallbackValue?: unknown, 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: unknown): void;
+    sendResponse(response: IExecuteResponsePromiseData): void;
+    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: never[]) => unknown;
+    };
+}
+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<unknown>;
+    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?: unknown): 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: unknown): void;
+    sendResponse(response: IExecuteResponsePromiseData): void;
+    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>;
+        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>;
+        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>;
+        returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
+        normalizeItems(items: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
+        [key: string]: (...args: never[]) => unknown;
+    };
+};
+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?: unknown): 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>;
+        prepareBinaryData(binaryData: Buffer, filePath?: string, mimeType?: string): Promise<IBinaryData>;
+        [key: string]: (...args: never[]) => unknown;
+    };
+}
+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: never[]) => unknown;
+    };
+}
+export interface ILoadOptionsFunctions {
+    getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+    getNode(): INode;
+    getNodeParameter(parameterName: string, fallbackValue?: unknown): 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>;
+        requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: unknown, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<unknown>;
+        httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<IN8nHttpResponse | IN8nHttpFullResponse>;
+        [key: string]: ((...args: never[]) => unknown) | undefined;
+    };
+}
+export interface IHookFunctions {
+    getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+    getMode(): WorkflowExecuteMode;
+    getActivationMode(): WorkflowActivateMode;
+    getNode(): INode;
+    getNodeWebhookUrl: (name: string) => string | undefined;
+    getNodeParameter(parameterName: string, fallbackValue?: unknown): 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: never[]) => unknown;
+    };
+}
+export interface IPollFunctions {
+    __emit(data: INodeExecutionData[][]): void;
+    getCredentials(type: string): Promise<ICredentialDataDecryptedObject | undefined>;
+    getMode(): WorkflowExecuteMode;
+    getActivationMode(): WorkflowActivateMode;
+    getNode(): INode;
+    getNodeParameter(parameterName: string, fallbackValue?: unknown): 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: never[]) => unknown;
+    };
+}
+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?: unknown): 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: never[]) => unknown;
+    };
+}
+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;
+}
+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 = 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?: unknown, 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: never[]) => unknown;
+    };
+    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]: unknown;
+    __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;
+}
+export type NodeParameterValue = string | number | boolean | undefined | null;
+export interface INodeParameters {
+    [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;
+    codeAutocomplete?: CodeAutocompleteTypes;
+    editor?: EditorTypes;
+    loadOptionsDependsOn?: string[];
+    loadOptionsMethod?: string;
+    loadOptions?: ILoadOptions;
+    maxValue?: number;
+    minValue?: number;
+    multipleValues?: boolean;
+    multipleValueButtonText?: string;
+    numberPrecision?: number;
+    password?: boolean;
+    rows?: number;
+    showAlpha?: boolean;
+    sortable?: boolean;
+    [key: string]: unknown;
+}
+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 = {
+    boolean: boolean;
+    number: number;
+    string: string;
+    "string-alphanumeric": string;
+    dateTime: string;
+    time: string;
+    array: unknown[];
+    object: object;
+    options: unknown;
+    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 declare namespace MultiPartFormData {
+    interface File {
+        filepath: string;
+        mimetype?: string;
+        originalFilename?: string;
+        newFilename: string;
+        size?: number;
+    }
+    type Request = express.Request<Record<string, never>, Record<string, never>, {
+        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: Record<string, unknown>;
+}
+export type 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;
+    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>;
+    manualTriggerFunction?: () => Promise<void>;
+    manualTriggerResponse?: Promise<INodeExecutionData[][]>;
+}
+export interface SupplyData {
+    metadata?: IDataObject;
+    response: unknown;
+    closeFunction?: () => Promise<void>;
+}
+declare namespace ExecuteFunctions {
+    namespace StringReturning {
+        type NodeParameter = "binaryProperty" | "binaryPropertyName" | "binaryPropertyOutput" | "dataPropertyName" | "dataBinaryProperty" | "resource" | "operation" | "filePath" | "encodingType";
+    }
+    namespace NumberReturning {
+        type NodeParameter = "limit";
+    }
+    namespace BooleanReturning {
+        type NodeParameter = "binaryData" | "download" | "jsonParameters" | "returnAll" | "rawData" | "resolveData";
+    }
+    namespace RecordReturning {
+        type NodeParameter = "additionalFields" | "filters" | "options" | "updateFields";
+    }
+    export type GetNodeParameterFn = {
+        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?: unknown, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
+    };
+    export {};
+}
+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?: {
+            [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;
+    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;
+}
+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 declare const NodeConnectionTypes: {
+    readonly AiAgent: "ai_agent";
+    readonly AiChain: "ai_chain";
+    readonly AiDocument: "ai_document";
+    readonly AiEmbedding: "ai_embedding";
+    readonly AiLanguageModel: "ai_languageModel";
+    readonly AiMemory: "ai_memory";
+    readonly AiOutputParser: "ai_outputParser";
+    readonly AiRetriever: "ai_retriever";
+    readonly AiTextSplitter: "ai_textSplitter";
+    readonly AiTool: "ai_tool";
+    readonly AiVectorStore: "ai_vectorStore";
+    readonly Main: "main";
+};
+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;
+    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;
+    property?: string;
+    propertyInDotNotation?: boolean;
+    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;
+    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[];
+}
+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]: unknown;
+    $binary: unknown;
+    $data: unknown;
+    $env: unknown;
+    $evaluateExpression: unknown;
+    $item: unknown;
+    $items: unknown;
+    $json: unknown;
+    $node: unknown;
+    $parameter: unknown;
+    $position: unknown;
+    $workflow: unknown;
+    $: unknown;
+    $input: unknown;
+    $thisItem: unknown;
+    $thisRunIndex: number;
+    $thisItemIndex: number;
+    $now: unknown;
+    $today: unknown;
+}
+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?: unknown;
+    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;
+    ensureType?: EnsureTypeOptions;
+    extractValue?: boolean;
+    rawExpressions?: boolean;
+}
+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 {
+    [key: string]: ITaskData[];
+}
+export interface ITaskData {
+    startTime: number;
+    executionTime: number;
+    data?: ITaskDataConnections;
+    error?: ExecutionError;
+}
+export interface ITaskDataConnections {
+    [key: string]: Array<INodeExecutionData[] | null>;
+}
+export interface IWaitingForExecution {
+    [key: string]: {
+        [key: number]: ITaskDataConnections;
+    };
+}
+export interface IWorkflowBase {
+    id?: unknown;
+    name: string;
+    active: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    nodes: INode[];
+    connections: IConnections;
+    settings?: IWorkflowSettings;
+    staticData?: IDataObject;
+    teamId?: string | null;
+}
+export interface IWorkflowCredentials {
+    [credentialType: string]: {
+        [id: string]: ICredentialsEncrypted;
+    };
+}
+export interface IWorkflowExecuteHooks {
+    [key: string]: Array<(...args: never[]) => 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?: unknown) => Promise<unknown>;
+    executionId?: string;
+    hooks?: WorkflowHooks;
+    httpResponse?: express.Response;
+    httpRequest?: express.Request;
+    restApiUrl: string;
+    sendMessageToUI?: (source: string, message: unknown) => 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 {
+    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 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;
+        };
+    };
+}>;
+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;
+    previousNodeRun?: number;
+}
+export interface IPairedItemData {
+    item: number;
+    input?: number;
+    sourceOverwrite?: ISourceData;
+}
+export type CloseFunction = () => Promise<void>;
+export interface SupplyData {
+    metadata?: IDataObject;
+    response: unknown;
+    closeFunction?: CloseFunction;
+}
+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";
+export {};
+//# sourceMappingURL=Interfaces.d.ts.map