import type { CallbackManager as CallbackManagerLC } from '@langchain/core/callbacks/manager';
import type { LogScope } from '@n8n/config';
import type { AxiosProxyConfig, GenericAbortSignal } from 'axios';
import type * as express from 'express';
import type FormData from 'form-data';
import type { PathLike } from 'fs';
import type { IncomingHttpHeaders } from 'http';
import type { ReplyHeaders, RequestBodyMatcher, RequestHeaderMatcher } from 'nock';
import type { Client as SSHClient } from 'ssh2';
import type { Readable } from 'stream';
import type { SecureContextOptions } from 'tls';
import type { URLSearchParams } from 'url';
import type { CODE_EXECUTION_MODES, CODE_LANGUAGES, LOG_LEVELS } from './constants';
import type { IDataTableProjectAggregateService, IDataTableProjectService } from './data-table.types';
import type { IDeferredPromise } from './deferred-promise';
import type { ExecutionCancelledError } from './errors';
import type { ExpressionError } from './errors/expression.error';
import type { NodeApiError } from './errors/node-api.error';
import type { NodeOperationError } from './errors/node-operation.error';
import type { WorkflowActivationError } from './errors/workflow-activation.error';
import type { WorkflowOperationError } from './errors/workflow-operation.error';
import type { ExecutionStatus } from './execution-status';
import type { Result } from './result';
import type { Workflow } from './workflow';
import type { EnvProviderState } from './workflow-data-proxy-env-provider';
export interface IAdditionalCredentialOptions {
    oauth2?: IOAuth2Options;
    credentialsDecrypted?: ICredentialsDecrypted;
}
export type IAllExecuteFunctions = IExecuteFunctions | IExecutePaginationFunctions | IExecuteSingleFunctions | ISupplyDataFunctions | IHookFunctions | ILoadOptionsFunctions | IPollFunctions | ITriggerFunctions | IWebhookFunctions;
export type BinaryFileType = 'text' | 'json' | 'image' | 'audio' | 'video' | 'pdf' | 'html';
export interface IBinaryData {
    [key: string]: string | number | undefined;
    data: string;
    mimeType: string;
    fileType?: BinaryFileType;
    fileName?: string;
    directory?: string;
    fileExtension?: string;
    fileSize?: string;
    id?: string;
}
export interface IOAuth2Options {
    includeCredentialsOnRefreshOnBody?: boolean;
    property?: string;
    tokenType?: string;
    keepBearer?: boolean;
    tokenExpiredStatusCode?: number;
    keyToIncludeInAccessTokenHeader?: string;
}
export interface IConnection {
    node: string;
    type: NodeConnectionType;
    index: number;
}
export type ExecutionError = ExpressionError | WorkflowActivationError | WorkflowOperationError | ExecutionCancelledError | NodeOperationError | NodeApiError;
export interface IGetCredentials {
    get(type: string, id: string | null): Promise<ICredentialsEncrypted>;
}
export declare abstract class ICredentials<T extends object = ICredentialDataDecryptedObject> {
    id?: string;
    name: string;
    type: string;
    data: string | undefined;
    constructor(nodeCredentials: INodeCredentialsDetails, type: string, data?: string);
    abstract getData(nodeType?: string): T;
    abstract getDataToSave(): ICredentialsEncrypted;
    abstract setData(data: T): void;
}
export interface IUser {
    id: string;
    email: string;
    firstName: string;
    lastName: string;
}
export type ProjectSharingData = {
    id: string;
    name: string | null;
    icon: {
        type: 'emoji' | 'icon';
        value: string;
    } | null;
    type: 'personal' | 'team' | 'public';
    createdAt: string;
    updatedAt: string;
};
export interface ICredentialsDecrypted<T extends object = ICredentialDataDecryptedObject> {
    id: string;
    name: string;
    type: string;
    data?: T;
    homeProject?: ProjectSharingData;
    sharedWithProjects?: ProjectSharingData[];
}
export interface ICredentialsEncrypted {
    id?: string;
    name: string;
    type: string;
    data?: string;
}
export interface ICredentialsExpressionResolveValues {
    connectionInputData: INodeExecutionData[];
    itemIndex: number;
    node: INode;
    runExecutionData: IRunExecutionData | null;
    runIndex: number;
    workflow: Workflow;
}
export interface IRequestOptionsSimplified {
    auth?: {
        username: string;
        password: string;
        sendImmediately?: boolean;
    };
    body: IDataObject;
    headers: IDataObject;
    qs: IDataObject;
}
export interface IRequestOptionsSimplifiedAuth {
    auth?: {
        username: string;
        password: string;
        sendImmediately?: boolean;
    };
    body?: IDataObject;
    headers?: IDataObject;
    qs?: IDataObject;
    url?: string;
    skipSslCertificateValidation?: boolean | string;
}
export interface IHttpRequestHelper {
    helpers: {
        httpRequest: IAllExecuteFunctions['helpers']['httpRequest'];
    };
}
export declare abstract class ICredentialsHelper {
    abstract getParentTypes(name: string): string[];
    abstract authenticate(credentials: ICredentialDataDecryptedObject, typeName: string, requestOptions: IHttpRequestOptions | IRequestOptionsSimplified, workflow: Workflow, node: INode): Promise<IHttpRequestOptions>;
    abstract preAuthentication(helpers: IHttpRequestHelper, credentials: ICredentialDataDecryptedObject, typeName: string, node: INode, credentialsExpired: boolean): Promise<ICredentialDataDecryptedObject | undefined>;
    abstract getCredentials(nodeCredentials: INodeCredentialsDetails, type: string): Promise<ICredentials>;
    abstract getDecrypted(additionalData: IWorkflowExecuteAdditionalData, nodeCredentials: INodeCredentialsDetails, type: string, mode: WorkflowExecuteMode, executeData?: IExecuteData, raw?: boolean, expressionResolveValues?: ICredentialsExpressionResolveValues): Promise<ICredentialDataDecryptedObject>;
    abstract updateCredentials(nodeCredentials: INodeCredentialsDetails, type: string, data: ICredentialDataDecryptedObject): Promise<void>;
    abstract updateCredentialsOauthTokenData(nodeCredentials: INodeCredentialsDetails, type: string, data: ICredentialDataDecryptedObject): Promise<void>;
    abstract getCredentialsProperties(type: string): INodeProperties[];
}
export interface IAuthenticateBase {
    type: string;
    properties: {
        [key: string]: string;
    } | IRequestOptionsSimplifiedAuth;
}
export interface IAuthenticateGeneric extends IAuthenticateBase {
    type: 'generic';
    properties: IRequestOptionsSimplifiedAuth;
}
export type IAuthenticate = ((credentials: ICredentialDataDecryptedObject, requestOptions: IHttpRequestOptions) => Promise<IHttpRequestOptions>) | IAuthenticateGeneric;
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 IAuthenticateRuleResponseSuccessBody extends IAuthenticateRuleBase {
    type: 'responseSuccessBody';
    properties: {
        message: string;
        key: string;
        value: any;
    };
}
type Override<A extends object, B extends object> = Omit<A, keyof B> & B;
export declare namespace DeclarativeRestApiSettings {
    type HttpRequestOptions = Override<IHttpRequestOptions, {
        skipSslCertificateValidation?: string | boolean;
        url?: string;
    }>;
    type ResultOptions = {
        maxResults?: number | string;
        options: HttpRequestOptions;
        paginate?: boolean | string;
        preSend: PreSendAction[];
        postReceive: Array<{
            data: {
                parameterValue: string | IDataObject | undefined;
            };
            actions: PostReceiveAction[];
        }>;
        requestOperations?: IN8nRequestOperations;
    };
}
export interface ICredentialTestRequest {
    request: DeclarativeRestApiSettings.HttpRequestOptions;
    rules?: IAuthenticateRuleResponseCode[] | IAuthenticateRuleResponseSuccessBody[];
}
export interface ICredentialTestRequestData {
    nodeType?: INodeType;
    testRequest: ICredentialTestRequest;
}
type ICredentialHttpRequestNode = {
    name: string;
    docsUrl: string;
    hidden?: boolean;
} & ({
    apiBaseUrl: string;
} | {
    apiBaseUrlPlaceholder: string;
});
export interface ICredentialType {
    name: string;
    displayName: string;
    icon?: Icon;
    iconColor?: ThemeIconColor;
    iconUrl?: Themed<string>;
    extends?: string[];
    properties: INodeProperties[];
    documentationUrl?: string;
    __overwrittenProperties?: string[];
    authenticate?: IAuthenticate;
    preAuthentication?: (this: IHttpRequestHelper, credentials: ICredentialDataDecryptedObject) => Promise<IDataObject>;
    test?: ICredentialTestRequest;
    genericAuth?: boolean;
    httpRequestNode?: ICredentialHttpRequestNode;
    supportedNodes?: string[];
}
export interface ICredentialTypes {
    recognizes(credentialType: string): boolean;
    getByName(credentialType: string): ICredentialType;
    getSupportedNodes(type: string): string[];
    getParentTypes(typeName: string): string[];
}
export interface ICredentialData {
    id?: string;
    name: string;
    data: string;
}
export type CredentialInformation = string | string[] | number | boolean | IDataObject | IDataObject[];
export interface ICredentialDataDecryptedObject {
    [key: string]: CredentialInformation;
}
export type NodeInputConnections = Array<IConnection[] | null>;
export interface INodeConnection {
    sourceIndex: number;
    destinationIndex: number;
}
export interface INodeConnections {
    [key: string]: NodeInputConnections;
}
export interface IConnections {
    [key: string]: INodeConnections;
}
export type GenericValue = string | object | number | boolean | undefined | null;
export type CloseFunction = () => Promise<void>;
export interface IDataObject {
    [key: string]: GenericValue | IDataObject | GenericValue[] | IDataObject[];
}
export type IExecuteResponsePromiseData = IDataObject | IN8nHttpFullResponse;
export interface INodeTypeNameVersion {
    name: string;
    version: number;
}
export interface IRunNodeResponse {
    data: INodeExecutionData[][] | null | undefined;
    hints?: NodeExecutionHint[];
    closeFunction?: CloseFunction;
}
export interface ISourceDataConnections {
    [key: string]: Array<ISourceData[] | null>;
}
export interface IExecuteData {
    data: ITaskDataConnections;
    metadata?: ITaskMetadata;
    node: INode;
    source: ITaskDataConnectionsSource | null;
    runIndex?: number;
}
export type IContextObject = {
    [key: string]: any;
};
export interface IExecuteContextData {
    [key: string]: IContextObject;
}
export type IHttpRequestMethods = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
/** used in helpers.httpRequest(WithAuthentication) */
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;
        sendImmediately?: boolean;
    };
    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;
    abortSignal?: GenericAbortSignal;
}
/**
 * used in helpers.request(WithAuthentication)
 * @see IHttpRequestOptions
 * @deprecated Prefer using IHttpRequestOptions
 */
export interface IRequestOptions {
    baseURL?: string;
    uri?: string;
    url?: string;
    method?: IHttpRequestMethods;
    qs?: IDataObject;
    qsStringifyOptions?: {
        arrayFormat: 'repeat' | 'brackets' | 'indices';
    };
    useQuerystring?: boolean;
    headers?: IDataObject;
    auth?: Partial<{
        sendImmediately: boolean;
        bearer: string;
        user: string;
        username: string;
        password: string;
        pass: string;
    }>;
    body?: any;
    formData?: IDataObject | FormData;
    form?: IDataObject | FormData;
    json?: boolean;
    useStream?: boolean;
    encoding?: string | null;
    timeout?: number;
    rejectUnauthorized?: boolean;
    proxy?: string | AxiosProxyConfig;
    simple?: boolean;
    gzip?: boolean;
    resolveWithFullResponse?: boolean;
    /** Whether to follow GET or HEAD HTTP 3xx redirects @default true */
    followRedirect?: boolean;
    /** Whether to follow **All** HTTP 3xx redirects @default false */
    followAllRedirects?: boolean;
    /** Max number of redirects to follow @default 21 */
    maxRedirects?: number;
    agentOptions?: SecureContextOptions;
}
export interface PaginationOptions {
    binaryResult?: boolean;
    continue: boolean | string;
    request: IRequestOptionsSimplifiedAuth;
    requestInterval: number;
    maxRequests?: number;
}
export type IN8nHttpResponse = IDataObject | Buffer | GenericValue | GenericValue[] | null;
export interface IN8nHttpFullResponse {
    body: IN8nHttpResponse | Readable;
    __bodyResolved?: boolean;
    headers: IDataObject;
    statusCode: number;
    statusMessage?: string;
}
export interface IN8nRequestOperations {
    pagination?: IN8nRequestOperationPaginationGeneric | IN8nRequestOperationPaginationOffset | ((this: IExecutePaginationFunctions, requestOptions: DeclarativeRestApiSettings.ResultOptions) => Promise<INodeExecutionData[]>);
}
export interface IN8nRequestOperationPaginationBase {
    type: string;
    properties: {
        [key: string]: unknown;
    };
}
export interface IN8nRequestOperationPaginationGeneric extends IN8nRequestOperationPaginationBase {
    type: 'generic';
    properties: {
        continue: boolean | string;
        request: IRequestOptionsSimplifiedAuth;
    };
}
export interface IN8nRequestOperationPaginationOffset extends IN8nRequestOperationPaginationBase {
    type: 'offset';
    properties: {
        limitParameter: string;
        offsetParameter: string;
        pageSize: number;
        rootProperty?: string;
        type: 'body' | 'query';
    };
}
export type EnsureTypeOptions = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'json';
export interface IGetNodeParameterOptions {
    contextNode?: INode;
    ensureType?: EnsureTypeOptions;
    extractValue?: boolean;
    rawExpressions?: boolean;
    skipValidation?: boolean;
}
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?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    };
    export {};
}
export interface IExecuteWorkflowInfo {
    code?: IWorkflowBase;
    id?: string;
}
export type ICredentialTestFunction = (this: ICredentialTestFunctions, credential: ICredentialsDecrypted<ICredentialDataDecryptedObject>) => Promise<INodeCredentialTestResult>;
export interface ICredentialTestFunctions {
    logger: Logger;
    helpers: SSHTunnelFunctions & {
        request: (uriOrObject: string | object, options?: object) => Promise<any>;
    };
}
export interface BaseHelperFunctions {
    createDeferredPromise: <T = void>() => IDeferredPromise<T>;
    returnJsonArray(jsonData: IDataObject | IDataObject[]): INodeExecutionData[];
}
export interface FileSystemHelperFunctions {
    createReadStream(path: PathLike): Promise<Readable>;
    getStoragePath(): string;
    writeContentToFile(path: PathLike, content: string | Buffer | Readable, flag?: string): Promise<void>;
}
export interface BinaryHelperFunctions {
    prepareBinaryData(binaryData: Buffer | Readable, filePath?: string, mimeType?: string): Promise<IBinaryData>;
    setBinaryDataBuffer(data: IBinaryData, binaryData: Buffer): Promise<IBinaryData>;
    /** @deprecated */
    copyBinaryFile(): Promise<never>;
    binaryToBuffer(body: Buffer | Readable): Promise<Buffer>;
    binaryToString(body: Buffer | Readable, encoding?: BufferEncoding): Promise<string>;
    getBinaryPath(binaryDataId: string): string;
    getBinaryStream(binaryDataId: string, chunkSize?: number): Promise<Readable>;
    createBinarySignedUrl(binaryData: IBinaryData, expiresIn?: string): string;
    getBinaryMetadata(binaryDataId: string): Promise<{
        fileName?: string;
        mimeType?: string;
        fileSize: number;
    }>;
}
export type DeduplicationScope = 'node' | 'workflow';
export type DeduplicationItemTypes = string | number;
export type DeduplicationMode = 'entries' | 'latestIncrementalKey' | 'latestDate';
export interface IProcessedDataLatest {
    mode: DeduplicationMode;
    data: DeduplicationItemTypes;
}
export interface IProcessedDataEntries {
    mode: DeduplicationMode;
    data: DeduplicationItemTypes[];
}
export interface IDeduplicationOutput {
    new: DeduplicationItemTypes[];
    processed: DeduplicationItemTypes[];
}
export interface IDeduplicationOutputItems {
    new: IDataObject[];
    processed: IDataObject[];
}
export interface ICheckProcessedOptions {
    mode: DeduplicationMode;
    maxEntries?: number;
}
export interface DeduplicationHelperFunctions {
    checkProcessedAndRecord(items: DeduplicationItemTypes[], scope: DeduplicationScope, options: ICheckProcessedOptions): Promise<IDeduplicationOutput>;
    checkProcessedItemsAndRecord(propertyName: string, items: IDataObject[], scope: DeduplicationScope, options: ICheckProcessedOptions): Promise<IDeduplicationOutputItems>;
    removeProcessed(items: DeduplicationItemTypes[], scope: DeduplicationScope, options: ICheckProcessedOptions): Promise<void>;
    clearAllProcessedItems(scope: DeduplicationScope, options: ICheckProcessedOptions): Promise<void>;
    getProcessedDataCount(scope: DeduplicationScope, options: ICheckProcessedOptions): Promise<number>;
}
interface NodeHelperFunctions {
    copyBinaryFile(filePath: string, fileName: string, mimeType?: string): Promise<IBinaryData>;
}
export interface RequestHelperFunctions {
    httpRequest(requestOptions: IHttpRequestOptions): Promise<any>;
    httpRequestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IHttpRequestOptions, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<any>;
    requestWithAuthenticationPaginated(this: IAllExecuteFunctions, requestOptions: IRequestOptions, itemIndex: number, paginationOptions: PaginationOptions, credentialsType?: string, additionalCredentialOptions?: IAdditionalCredentialOptions): Promise<any[]>;
    /**
     * @deprecated Use .httpRequest instead
     * @see RequestHelperFunctions.httpRequest
     */
    request(uriOrObject: string | IRequestOptions, options?: IRequestOptions): Promise<any>;
    /**
     * @deprecated Use .httpRequestWithAuthentication instead
     * @see RequestHelperFunctions.requestWithAuthentication
     */
    requestWithAuthentication(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IRequestOptions, additionalCredentialOptions?: IAdditionalCredentialOptions, itemIndex?: number): Promise<any>;
    /**
     * @deprecated Use .httpRequestWithAuthentication instead
     * @see RequestHelperFunctions.requestWithAuthentication
     */
    requestOAuth1(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IRequestOptions): Promise<any>;
    /**
     * @deprecated Use .httpRequestWithAuthentication instead
     * @see RequestHelperFunctions.requestWithAuthentication
     */
    requestOAuth2(this: IAllExecuteFunctions, credentialsType: string, requestOptions: IRequestOptions, oAuth2Options?: IOAuth2Options): Promise<any>;
}
export type SSHCredentials = {
    sshHost: string;
    sshPort: number;
    sshUser: string;
} & ({
    sshAuthenticateWith: 'password';
    sshPassword: string;
} | {
    sshAuthenticateWith: 'privateKey';
    privateKey: string;
    passphrase?: string;
});
export interface SSHTunnelFunctions {
    getSSHClient(credentials: SSHCredentials, abortController?: AbortController): Promise<SSHClient>;
    updateLastUsed(client: SSHClient): void;
}
type CronUnit = number | '*' | `*/${number}`;
export type CronExpression = `${CronUnit} ${CronUnit} ${CronUnit} ${CronUnit} ${CronUnit} ${CronUnit}`;
type CronRecurrenceRule = {
    activated: false;
} | {
    activated: true;
    index: number;
    intervalSize: number;
    typeInterval: 'hours' | 'days' | 'weeks' | 'months';
};
export type CronContext = {
    nodeId: string;
    workflowId: string;
    timezone: string;
    expression: CronExpression;
    recurrence?: CronRecurrenceRule;
};
export type Cron = {
    expression: CronExpression;
    recurrence?: CronRecurrenceRule;
};
export interface SchedulingFunctions {
    registerCron(cron: Cron, onTick: () => void): void;
}
export type NodeTypeAndVersion = {
    name: string;
    type: string;
    typeVersion: number;
    disabled: boolean;
    parameters?: INodeParameters;
};
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;
    /** Get the waiting resume url signed with the signature token */
    getSignedResumeUrl(parameters?: Record<string, string>): string;
    /** Set requirement in the execution for signature token validation */
    setSignatureValidationRequired(): void;
    getChildNodes(nodeName: string, options?: {
        includeNodeParameters?: boolean;
    }): NodeTypeAndVersion[];
    getParentNodes(nodeName: string, options?: {
        includeNodeParameters?: boolean;
        connectionType?: NodeConnectionType;
        depth?: number;
    }): NodeTypeAndVersion[];
    getKnownNodeTypes(): IDataObject;
    getMode?: () => WorkflowExecuteMode;
    getActivationMode?: () => WorkflowActivateMode;
    getChatTrigger: () => INode | null;
    /** @deprecated */
    prepareOutputData(outputData: INodeExecutionData[]): Promise<INodeExecutionData[][]>;
}
type FunctionsBaseWithRequiredKeys<Keys extends keyof FunctionsBase> = FunctionsBase & {
    [K in Keys]: NonNullable<FunctionsBase[K]>;
};
export type ContextType = 'flow' | 'node';
export type DataTableProxyProvider = {
    getDataTableAggregateProxy(workflow: Workflow, node: INode, projectId?: string): Promise<IDataTableProjectAggregateService>;
    getDataTableProxy(workflow: Workflow, node: INode, dataTableId: string, projectId?: string): Promise<IDataTableProjectService>;
};
export type DataTableProxyFunctions = {
    getDataTableAggregateProxy?(): Promise<IDataTableProjectAggregateService>;
    getDataTableProxy?(dataTableId: string): Promise<IDataTableProjectService>;
};
type BaseExecutionFunctions = FunctionsBaseWithRequiredKeys<'getMode'> & {
    continueOnFail(): boolean;
    setMetadata(metadata: ITaskMetadata): void;
    evaluateExpression(expression: string, itemIndex: number): NodeParameterValueType;
    getContext(type: ContextType): IContextObject;
    getExecuteData(): IExecuteData;
    getWorkflowDataProxy(itemIndex: number): IWorkflowDataProxyData;
    getInputSourceData(inputIndex?: number, connectionType?: NodeConnectionType): ISourceData;
    getExecutionCancelSignal(): AbortSignal | undefined;
    onExecutionCancellation(handler: () => unknown): void;
    logAiEvent(eventName: AiEvent, msg?: string): void;
};
export type IExecuteFunctions = ExecuteFunctions.GetNodeParameterFn & BaseExecutionFunctions & {
    executeWorkflow(workflowInfo: IExecuteWorkflowInfo, inputData?: INodeExecutionData[], parentCallbackManager?: CallbackManager, options?: {
        doNotWaitToFinish?: boolean;
        parentExecution?: RelatedExecution;
    }): Promise<ExecuteWorkflowData>;
    getExecutionDataById(executionId: string): Promise<IRunExecutionData | undefined>;
    getInputConnectionData(connectionType: AINodeConnectionType, itemIndex: number, inputIndex?: number): Promise<unknown>;
    getInputData(inputIndex?: number, connectionType?: NodeConnectionType): INodeExecutionData[];
    getNodeInputs(): INodeInputConfiguration[];
    getNodeOutputs(): INodeOutputConfiguration[];
    putExecutionToWait(waitTill: Date): Promise<void>;
    sendMessageToUI(message: any): void;
    sendResponse(response: IExecuteResponsePromiseData): void;
    sendChunk(type: ChunkType, itemIndex: number, content?: IDataObject | string): void;
    isStreaming(): boolean;
    addInputData(connectionType: NodeConnectionType, data: INodeExecutionData[][] | ExecutionError, runIndex?: number): {
        index: number;
    };
    addOutputData(connectionType: NodeConnectionType, currentNodeRunIndex: number, data: INodeExecutionData[][] | ExecutionError, metadata?: ITaskMetadata, sourceNodeRunIndex?: number): void;
    addExecutionHints(...hints: NodeExecutionHint[]): void;
    nodeHelpers: NodeHelperFunctions;
    helpers: RequestHelperFunctions & BaseHelperFunctions & BinaryHelperFunctions & DeduplicationHelperFunctions & FileSystemHelperFunctions & SSHTunnelFunctions & DataTableProxyFunctions & {
        normalizeItems(items: INodeExecutionData | INodeExecutionData[]): INodeExecutionData[];
        constructExecutionMetaData(inputData: INodeExecutionData[], options: {
            itemData: IPairedItemData | IPairedItemData[];
        }): NodeExecutionWithMetadata[];
        assertBinaryData(itemIndex: number, parameterData: string | IBinaryData): IBinaryData;
        getBinaryDataBuffer(itemIndex: number, parameterData: string | IBinaryData): Promise<Buffer>;
        detectBinaryEncoding(buffer: Buffer): string;
        copyInputItems(items: INodeExecutionData[], properties: string[]): IDataObject[];
    };
    getParentCallbackManager(): CallbackManager | undefined;
    startJob<T = unknown, E = unknown>(jobType: string, settings: unknown, itemIndex: number): Promise<Result<T, E>>;
};
export interface IExecuteSingleFunctions extends BaseExecutionFunctions {
    getInputData(inputIndex?: number, connectionType?: NodeConnectionType): INodeExecutionData;
    getItemIndex(): number;
    getNodeParameter(parameterName: string, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    helpers: RequestHelperFunctions & BaseHelperFunctions & BinaryHelperFunctions & {
        assertBinaryData(propertyName: string, inputIndex?: number): IBinaryData;
        getBinaryDataBuffer(propertyName: string, inputIndex?: number): Promise<Buffer>;
        detectBinaryEncoding(buffer: Buffer): string;
    };
}
export type ISupplyDataFunctions = ExecuteFunctions.GetNodeParameterFn & FunctionsBaseWithRequiredKeys<'getMode'> & Pick<IExecuteFunctions, 'addInputData' | 'addOutputData' | 'getInputConnectionData' | 'getInputData' | 'getNodeOutputs' | 'executeWorkflow' | 'sendMessageToUI' | 'startJob' | 'helpers'> & {
    getNextRunIndex(): number;
    continueOnFail(): boolean;
    evaluateExpression(expression: string, itemIndex: number): NodeParameterValueType;
    getWorkflowDataProxy(itemIndex: number): IWorkflowDataProxyData;
    getExecutionCancelSignal(): AbortSignal | undefined;
    onExecutionCancellation(handler: () => unknown): void;
    logAiEvent(eventName: AiEvent, msg?: string): void;
    cloneWith(replacements: {
        runIndex: number;
        inputData: INodeExecutionData[][];
    }): ISupplyDataFunctions;
};
export interface IExecutePaginationFunctions extends IExecuteSingleFunctions {
    makeRoutingRequest(this: IAllExecuteFunctions, requestOptions: DeclarativeRestApiSettings.ResultOptions): Promise<INodeExecutionData[]>;
}
export interface ILoadOptionsFunctions extends FunctionsBase {
    getNodeParameter(parameterName: string, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    getCurrentNodeParameter(parameterName: string, options?: IGetNodeParameterOptions): NodeParameterValueType | object | undefined;
    getCurrentNodeParameters(): INodeParameters | undefined;
    helpers: RequestHelperFunctions & SSHTunnelFunctions & DataTableProxyFunctions;
}
export type FieldValueOption = {
    name: string;
    type: FieldType | 'any';
};
export type IWorkflowNodeContext = ExecuteFunctions.GetNodeParameterFn & Pick<FunctionsBase, 'getNode' | 'getWorkflow'>;
export interface ILocalLoadOptionsFunctions {
    getWorkflowNodeContext(nodeType: string): Promise<IWorkflowNodeContext | null>;
}
export interface IWorkflowLoader {
    get(workflowId: string): Promise<IWorkflowBase>;
}
export interface IPollFunctions extends FunctionsBaseWithRequiredKeys<'getMode' | 'getActivationMode'> {
    __emit(data: INodeExecutionData[][], responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>, donePromise?: IDeferredPromise<IRun>): void;
    __emitError(error: Error, responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>): void;
    getNodeParameter(parameterName: string, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    helpers: RequestHelperFunctions & BaseHelperFunctions & BinaryHelperFunctions & SchedulingFunctions;
}
export interface ITriggerFunctions extends FunctionsBaseWithRequiredKeys<'getMode' | 'getActivationMode'> {
    emit(data: INodeExecutionData[][], responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>, donePromise?: IDeferredPromise<IRun>): void;
    emitError(error: Error, responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>): void;
    getNodeParameter(parameterName: string, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    helpers: RequestHelperFunctions & BaseHelperFunctions & BinaryHelperFunctions & SSHTunnelFunctions & SchedulingFunctions;
}
export interface IHookFunctions extends FunctionsBaseWithRequiredKeys<'getMode' | 'getActivationMode'> {
    getWebhookName(): string;
    getWebhookDescription(name: WebhookType): IWebhookDescription | undefined;
    getNodeWebhookUrl: (name: WebhookType) => string | undefined;
    getNodeParameter(parameterName: string, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    helpers: RequestHelperFunctions;
}
export interface IWebhookFunctions extends FunctionsBaseWithRequiredKeys<'getMode'> {
    getBodyData(): IDataObject;
    getHeaderData(): IncomingHttpHeaders;
    getInputConnectionData(connectionType: AINodeConnectionType, itemIndex: number, inputIndex?: number): Promise<unknown>;
    getNodeParameter(parameterName: string, fallbackValue?: any, options?: IGetNodeParameterOptions): NodeParameterValueType | object;
    getNodeWebhookUrl: (name: WebhookType) => string | undefined;
    evaluateExpression(expression: string, itemIndex?: number): NodeParameterValueType;
    getParamsData(): object;
    getQueryData(): object;
    getRequestObject(): express.Request;
    getResponseObject(): express.Response;
    getWebhookName(): string;
    nodeHelpers: NodeHelperFunctions;
    helpers: RequestHelperFunctions & BaseHelperFunctions & BinaryHelperFunctions;
}
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;
    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;
    forceCustomOperation?: {
        resource: string;
        operation: string;
    };
}
export interface IPinData {
    [nodeName: string]: INodeExecutionData[];
}
export interface INodes {
    [key: string]: INode;
}
export interface IObservableObject {
    [key: string]: any;
    __dataChanged: boolean;
}
export interface IBinaryKeyData {
    [key: string]: IBinaryData;
}
export interface IPairedItemData {
    item: number;
    input?: number;
    sourceOverwrite?: ISourceData;
}
export interface INodeExecutionData {
    [key: string]: IDataObject | IBinaryKeyData | IPairedItemData | IPairedItemData[] | NodeApiError | NodeOperationError | number | string | undefined;
    json: IDataObject;
    binary?: IBinaryKeyData;
    error?: NodeApiError | NodeOperationError;
    pairedItem?: IPairedItemData | IPairedItemData[] | number;
    metadata?: {
        subExecution: RelatedExecution;
    };
    evaluationData?: Record<string, GenericValue>;
    /**
     * Use this key to send a message to the chat.
     *
     * - Workflow has to be started by a chat node.
     * - Put execution to wait after sending.
     *
     * See example in
     * packages/@n8n/nodes-langchain/nodes/trigger/ChatTrigger/Chat.node.ts
     */
    sendMessage?: string;
    /**
     * @deprecated This key was added by accident and should not be used as it
     * will be removed in future. For more information see PR #12469.
     */
    index?: number;
}
export type NodeParameterValue = string | number | boolean | undefined | null;
export type ResourceLocatorModes = 'id' | 'url' | 'list' | string;
export interface IResourceLocatorResult {
    name: string;
    value: string;
    url?: string;
}
export interface INodeParameterResourceLocator {
    __rl: true;
    mode: ResourceLocatorModes;
    value: Exclude<NodeParameterValue, boolean>;
    cachedResultName?: string;
    cachedResultUrl?: string;
    __regex?: string;
}
export type NodeParameterValueType = NodeParameterValue | INodeParameters | INodeParameterResourceLocator | ResourceMapperValue | FilterValue | AssignmentCollectionValue | NodeParameterValue[] | INodeParameters[] | INodeParameterResourceLocator[] | ResourceMapperValue[];
export interface INodeParameters {
    [key: string]: NodeParameterValueType;
}
export type NodePropertyTypes = 'boolean' | 'button' | 'collection' | 'color' | 'dateTime' | 'fixedCollection' | 'hidden' | 'json' | 'callout' | 'notice' | 'multiOptions' | 'number' | 'options' | 'string' | 'credentialsSelect' | 'resourceLocator' | 'curlImport' | 'resourceMapper' | 'filter' | 'assignmentCollection' | 'credentials' | 'workflowSelector';
export type CodeAutocompleteTypes = 'function' | 'functionItem';
export type EditorType = 'codeNodeEditor' | 'jsEditor' | 'htmlEditor' | 'sqlEditor' | 'cssEditor';
export type CodeNodeEditorLanguage = (typeof CODE_LANGUAGES)[number];
export type CodeExecutionMode = (typeof CODE_EXECUTION_MODES)[number];
export type SQLDialect = 'StandardSQL' | 'PostgreSQL' | 'MySQL' | 'OracleDB' | 'MariaSQL' | 'MSSQL' | 'SQLite' | 'Cassandra' | 'PLSQL';
export interface ILoadOptions {
    routing?: {
        operations?: IN8nRequestOperations;
        output?: INodeRequestOutput;
        request?: DeclarativeRestApiSettings.HttpRequestOptions;
    };
}
export type NodePropertyAction = {
    type: 'askAiCodeGeneration';
    handler?: string;
    target?: string;
};
export interface CalloutActionBase {
    type: string;
    label: string;
    icon?: string;
}
export interface CalloutActionOpenPreBuiltAgentsCollection extends CalloutActionBase {
    type: 'openPreBuiltAgentsCollection';
}
export interface CalloutActionOpenSampleWorkflowTemplate extends CalloutActionBase {
    type: 'openSampleWorkflowTemplate';
    templateId: string;
}
export type CalloutAction = CalloutActionOpenPreBuiltAgentsCollection | CalloutActionOpenSampleWorkflowTemplate;
export interface INodePropertyTypeOptions {
    buttonConfig?: {
        action?: string | NodePropertyAction;
        label?: string;
        hasInputField?: boolean;
        inputFieldMaxLength?: number;
    };
    containerClass?: string;
    alwaysOpenEditWindow?: boolean;
    codeAutocomplete?: CodeAutocompleteTypes;
    editor?: EditorType;
    editorIsReadOnly?: boolean;
    sqlDialect?: SQLDialect;
    loadOptionsDependsOn?: string[];
    loadOptionsMethod?: string;
    loadOptions?: ILoadOptions;
    maxValue?: number;
    minValue?: number;
    multipleValues?: boolean;
    multipleValueButtonText?: string;
    numberPrecision?: number;
    password?: boolean;
    rows?: number;
    showAlpha?: boolean;
    sortable?: boolean;
    expirable?: boolean;
    resourceMapper?: ResourceMapperTypeOptions;
    filter?: FilterTypeOptions;
    assignment?: AssignmentTypeOptions;
    minRequiredFields?: number;
    maxAllowedFields?: number;
    calloutAction?: CalloutAction;
    binaryDataProperty?: boolean;
    [key: string]: any;
}
export interface ResourceMapperTypeOptionsBase {
    mode: 'add' | 'update' | 'upsert' | 'map';
    valuesLabel?: string;
    fieldWords?: {
        singular: string;
        plural: string;
    };
    addAllFields?: boolean;
    noFieldsError?: string;
    multiKeyMatch?: boolean;
    supportAutoMap?: boolean;
    hideNoDataError?: boolean;
    matchingFieldsLabels?: {
        title?: string;
        description?: string;
        hint?: string;
    };
    showTypeConversionOptions?: boolean;
    allowEmptyValues?: boolean;
}
export type ResourceMapperTypeOptionsLocal = {
    resourceMapperMethod: string;
    localResourceMapperMethod?: never;
};
export type ResourceMapperTypeOptionsExternal = {
    localResourceMapperMethod: string;
    resourceMapperMethod?: never;
};
export type ResourceMapperTypeOptions = ResourceMapperTypeOptionsBase & (ResourceMapperTypeOptionsLocal | ResourceMapperTypeOptionsExternal);
type NonEmptyArray<T> = [T, ...T[]];
export type FilterTypeCombinator = 'and' | 'or';
export type FilterTypeOptions = {
    version: 1 | 2 | {};
    caseSensitive?: boolean | string;
    leftValue?: string;
    allowedCombinators?: NonEmptyArray<FilterTypeCombinator>;
    maxConditions?: number;
    typeValidation?: 'strict' | 'loose' | {};
};
export type AssignmentTypeOptions = Partial<{
    hideType?: boolean;
    defaultType?: FieldType | 'string';
    disableType?: boolean;
}>;
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> | undefined;
    };
    show?: {
        '@version'?: Array<number | DisplayCondition>;
        '@tool'?: boolean[];
        [key: string]: Array<NodeParameterValue | DisplayCondition> | undefined;
    };
    hideOnCloud?: boolean;
}
export interface ICredentialsDisplayOptions {
    hide?: {
        [key: string]: NodeParameterValue[] | undefined;
    };
    show?: {
        '@version'?: number[];
        [key: string]: NodeParameterValue[] | undefined;
    };
    hideOnCloud?: boolean;
}
export interface INodeProperties {
    displayName: string;
    name: string;
    type: NodePropertyTypes;
    typeOptions?: INodePropertyTypeOptions;
    default: NodeParameterValueType;
    description?: string;
    hint?: string;
    disabledOptions?: IDisplayOptions;
    displayOptions?: IDisplayOptions;
    options?: Array<INodePropertyOptions | INodeProperties | INodePropertyCollection>;
    placeholder?: string;
    isNodeSetting?: boolean;
    noDataExpression?: boolean;
    required?: boolean;
    routing?: INodePropertyRouting;
    credentialTypes?: Array<'extends:oAuth2Api' | 'extends:oAuth1Api' | 'has:authenticate' | 'has:genericAuth'>;
    extractValue?: INodePropertyValueExtractor;
    modes?: INodePropertyMode[];
    requiresDataPath?: 'single' | 'multiple';
    doNotInherit?: boolean;
    validateType?: FieldType;
    ignoreValidationDuringExecution?: boolean;
    allowArbitraryValues?: boolean;
}
export interface INodePropertyModeTypeOptions {
    searchListMethod?: string;
    searchFilterRequired?: boolean;
    searchable?: boolean;
    /**
     * If true, the resource locator will not show an error if the credentials are not selected
     */
    skipCredentialsCheckInRLC?: boolean;
    allowNewResource?: {
        label: string;
    } & ({
        method: string;
        url?: never;
        defaultName: string;
    } | {
        method?: never;
        url: string;
        defaultName?: never;
    });
}
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 INodePropertyModeValidation {
    type: string;
    properties: {};
}
export interface INodePropertyRegexValidation extends INodePropertyModeValidation {
    type: 'regex';
    properties: {
        regex: string;
        errorMessage: string;
    };
}
export interface INodePropertyOptions {
    name: string;
    value: string | number | boolean;
    action?: string;
    description?: string;
    routing?: INodePropertyRouting;
    outputConnectionType?: NodeConnectionType;
    inputSchema?: any;
    displayOptions?: IDisplayOptions;
    disabledOptions?: undefined;
}
export interface INodeListSearchItems extends INodePropertyOptions {
    icon?: string;
    url?: string;
}
export interface INodeListSearchResult {
    results: INodeListSearchItems[];
    paginationToken?: unknown;
}
export interface INodePropertyCollection {
    displayName: string;
    name: string;
    values: INodeProperties[];
}
export interface INodePropertyValueExtractorBase {
    type: string;
}
export interface INodePropertyValueExtractorRegex extends INodePropertyValueExtractorBase {
    type: 'regex';
    regex: string | RegExp;
}
export interface INodePropertyValueExtractorFunction {
    (this: IExecuteSingleFunctions, value: string | NodeParameterValue): Promise<string | NodeParameterValue> | string;
}
export type INodePropertyValueExtractor = INodePropertyValueExtractorRegex;
export interface IParameterDependencies {
    [key: string]: string[];
}
export type IParameterLabel = {
    size?: 'small' | 'medium';
};
export interface ITriggerResponse {
    closeFunction?: CloseFunction;
    manualTriggerFunction?: () => Promise<void>;
    manualTriggerResponse?: Promise<INodeExecutionData[][]>;
}
export interface ExecuteWorkflowData {
    executionId: string;
    data: Array<INodeExecutionData[] | null>;
    waitTill?: Date | null;
}
export type WebhookSetupMethodNames = 'checkExists' | 'create' | 'delete';
export declare namespace MultiPartFormData {
    interface File {
        filepath: string;
        mimetype?: string;
        originalFilename?: string;
        newFilename: string;
        size?: number;
    }
    type Request = express.Request<{}, {}, {
        data: Record<string, string | string[]>;
        files: Record<string, File | File[]>;
    }>;
}
export interface SupplyData {
    metadata?: IDataObject;
    response: unknown;
    closeFunction?: CloseFunction;
}
export type NodeOutput = INodeExecutionData[][] | NodeExecutionWithMetadata[][] | EngineRequest | null;
export interface INodeType {
    description: INodeTypeDescription;
    supplyData?(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
    execute?(this: IExecuteFunctions, response?: EngineResponse): Promise<NodeOutput>;
    /**
     * A function called when a node receives a chat message. Allows it to react
     * to the message before it gets executed.
     */
    onMessage?(context: IExecuteFunctions, data: INodeExecutionData): Promise<NodeOutput>;
    poll?(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
    trigger?(this: ITriggerFunctions): Promise<ITriggerResponse | undefined>;
    webhook?(this: IWebhookFunctions): Promise<IWebhookResponseData>;
    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?: {
        [name in WebhookType]?: {
            [method in WebhookSetupMethodNames]: (this: IHookFunctions) => Promise<boolean>;
        };
    };
    /**
     * Defines custom operations for nodes that do not implement an `execute` method, such as declarative nodes.
     * This function will be invoked instead of `execute` for a specific resource and operation.
     * Should be either `execute` or `customOperations` defined for a node, but not both.
     *
     * @property customOperations - Maps specific resource and operation to a custom function
     */
    customOperations?: {
        [resource: string]: {
            [operation: string]: (this: IExecuteFunctions) => Promise<NodeOutput>;
        };
    };
}
/**
 * Represents a request to execute a specific node and receive the result back.
 * This action tells the engine to execute the specified node with the provided input
 * and then call back the requesting node with the execution result.
 *
 * @template T - The type of metadata associated with this action
 */
type ExecuteNodeAction<T> = {
    /** The type identifier for this action */
    actionType: 'ExecutionNodeAction';
    /** The name of the node to be executed */
    nodeName: string;
    /** Input data to be passed to the node for execution */
    input: IDataObject;
    /** The type of connection this execution request uses */
    type: NodeConnectionType;
    /** Unique identifier for this execution request */
    id: string;
    /** Additional metadata for this execution request */
    metadata: T;
};
/**
 * Union type of all possible actions that nodes can request from the workflow engine.
 * Currently only contains ExecuteNodeAction, but will be extended with additional
 * action types as they are implemented.
 *
 * @template T - The type of metadata associated with this action
 */
type EngineAction<T = unknown> = ExecuteNodeAction<T>;
/**
 * A collection of actions that a node wants the engine to fulfill and call back with results.
 * The requesting node sends this to the engine and expects to receive an EngineResponse
 * containing the results of all requested actions.
 *
 * @template T - The type of metadata associated with this request
 *
 * @todo This should use `unknown`, but jest-mock-extended will turn this into
 * `Partial<unknown>` which `unknown` cannot be assigned to, which leads to a
 * lot of type errors in our tests.
 * The correct fix is to make a PR to jest-mock-extended and make it handle
 * `unknown` special, turning it into `unknown` instead of `Partial<unknown>`.
 */
export type EngineRequest<T = object> = {
    /** Array of actions that the requesting node wants the engine to fulfill */
    actions: Array<EngineAction<T>>;
    /** Metadata associated with this request */
    metadata: T;
};
/**
 * Result of executing a single node action within the workflow engine.
 * Contains the original action and the resulting task data.
 *
 * @template T - The type of metadata associated with this result
 */
export type ExecuteNodeResult<T = unknown> = {
    /** The action that was executed */
    action: ExecuteNodeAction<T>;
    /** The resulting task data from the execution */
    data: ITaskData;
};
/**
 * Union type of all possible results from engine actions.
 * Currently only contains ExecuteNodeResult, but will be extended with additional
 * result types as new action types are implemented.
 *
 * @template T - The type of metadata associated with this result
 */
type EngineResult<T> = ExecuteNodeResult<T>;
/**
 * Response structure returned from the workflow engine after execution.
 * Contains the results of all executed actions along with associated metadata.
 *
 * @template T - The type of metadata associated with this response
 */
export type EngineResponse<T = unknown> = {
    /** Array of results from each executed action */
    actionResponses: Array<EngineResult<T>>;
    /** Metadata associated with this response */
    metadata: T;
};
/**
 * This class serves as the base for all nodes using the new context API
 * having this as a class enables us to identify these instances at runtime
 */
export declare abstract class Node {
    abstract description: INodeTypeDescription;
    execute?(context: IExecuteFunctions, response?: EngineResponse): Promise<INodeExecutionData[][] | EngineRequest>;
    webhook?(context: IWebhookFunctions): Promise<IWebhookResponseData>;
    poll?(context: IPollFunctions): Promise<INodeExecutionData[][] | null>;
}
export interface IVersionedNodeType {
    nodeVersions: {
        [key: number]: INodeType;
    };
    currentVersion: number;
    description: INodeTypeBaseDescription;
    getNodeType: (version?: number) => INodeType;
}
export interface INodeCredentialTestResult {
    status: 'OK' | 'Error';
    message: string;
}
export interface INodeCredentialTestRequest {
    credentials: ICredentialsDecrypted;
}
export interface INodeCredentialDescription {
    name: string;
    required?: boolean;
    displayName?: string;
    disabledOptions?: ICredentialsDisplayOptions;
    displayOptions?: ICredentialsDisplayOptions;
    testedBy?: ICredentialTestRequest | string;
}
export type INodeIssueTypes = 'credentials' | 'execution' | 'input' | 'parameters' | 'typeUnknown';
export interface INodeIssueObjectProperty {
    [key: string]: string[];
}
export interface INodeIssueData {
    node: string;
    type: INodeIssueTypes;
    value: null | boolean | string | string[] | INodeIssueObjectProperty;
}
export interface INodeIssues {
    execution?: boolean;
    credentials?: INodeIssueObjectProperty;
    input?: INodeIssueObjectProperty;
    parameters?: INodeIssueObjectProperty;
    typeUnknown?: boolean;
    [key: string]: undefined | boolean | INodeIssueObjectProperty;
}
export interface IWorkflowIssues {
    [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 type IconRef = `fa:${string}` | `node:${string}.${string}`;
export type IconFile = `file:${string}.png` | `file:${string}.svg`;
export type Icon = IconRef | Themed<IconFile>;
type NodeGroupType = 'input' | 'output' | 'organization' | 'schedule' | 'transform' | 'trigger';
export interface INodeTypeBaseDescription {
    displayName: string;
    name: string;
    icon?: Icon;
    iconColor?: ThemeIconColor;
    iconUrl?: Themed<string>;
    badgeIconUrl?: Themed<string>;
    group: NodeGroupType[];
    description: string;
    documentationUrl?: string;
    subtitle?: string;
    defaultVersion?: number;
    codex?: CodexData;
    parameterPane?: 'wide';
    /**
     * Whether the node must be hidden in the node creator panel,
     * due to deprecation or as a special case (e.g. Start node)
     */
    hidden?: true;
    /**
     * Whether the node will be wrapped for tool-use by AI Agents,
     * optionally replacing provided parts of the description
     */
    usableAsTool?: true | UsableAsToolDescription;
}
/**
 * NodeDescription entries that replace the base node entries when
 * the node is used as a tool
 *
 * Note that the new codex is hardcoded and may not behave as expected
 * without additional changes to the implementation.
 */
export type UsableAsToolDescription = {
    replacements?: Partial<Omit<INodeTypeBaseDescription, 'usableAsTool'>>;
};
export interface INodePropertyRouting {
    operations?: IN8nRequestOperations;
    output?: INodeRequestOutput;
    request?: DeclarativeRestApiSettings.HttpRequestOptions;
    send?: INodeRequestSend;
}
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 IPostReceiveBase {
    type: string;
    enabled?: boolean | string;
    properties: {
        [key: string]: string | number | boolean | IDataObject;
    };
    errorMessage?: string;
}
export interface IPostReceiveBinaryData extends IPostReceiveBase {
    type: 'binaryData';
    properties: {
        destinationProperty: string;
    };
}
export interface IPostReceiveFilter extends IPostReceiveBase {
    type: 'filter';
    properties: {
        pass: boolean | string;
    };
}
export interface IPostReceiveLimit extends IPostReceiveBase {
    type: 'limit';
    properties: {
        maxResults: number | 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 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 AiReranker: "ai_reranker";
    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 AINodeConnectionType = Exclude<NodeConnectionType, typeof NodeConnectionTypes.Main>;
export declare const nodeConnectionTypes: NodeConnectionType[];
export interface INodeInputFilter {
    nodes?: string[];
    excludedNodes?: 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 ExpressionString = `={{${string}}}`;
export type NodeDefaults = Partial<{
    /**
     * @deprecated Use {@link INodeTypeBaseDescription.iconColor|iconColor} instead. `iconColor` supports dark mode and uses preset colors from n8n's design system.
     */
    color: string;
    name: string;
}>;
export interface INodeTypeDescription extends INodeTypeBaseDescription {
    version: number | number[];
    defaults: NodeDefaults;
    eventTriggerDescription?: string;
    activationMessage?: string;
    inputs: Array<NodeConnectionType | INodeInputConfiguration> | ExpressionString;
    requiredInputs?: string | number[] | number;
    inputNames?: string[];
    outputs: Array<NodeConnectionType | INodeOutputConfiguration> | ExpressionString;
    outputNames?: string[];
    properties: INodeProperties[];
    credentials?: INodeCredentialDescription[];
    maxNodes?: number;
    polling?: true | undefined;
    supportsCORS?: true | undefined;
    requestDefaults?: DeclarativeRestApiSettings.HttpRequestOptions;
    requestOperations?: IN8nRequestOperations;
    hooks?: {
        [key: string]: INodeHookDescription[] | undefined;
        activate?: INodeHookDescription[];
        deactivate?: INodeHookDescription[];
    };
    webhooks?: IWebhookDescription[];
    translation?: {
        [key: string]: object;
    };
    mockManualExecution?: true;
    triggerPanel?: TriggerPanelDefinition | boolean;
    extendsCredential?: string;
    hints?: NodeHint[];
    communityNodePackageVersion?: string;
    waitingNodeTooltip?: string;
    __loadOptionsMethods?: string[];
}
export type TriggerPanelDefinition = {
    hideContent?: boolean | string;
    header?: string;
    executionsHelp?: string | {
        active: string;
        inactive: string;
    };
    activationHint?: string | {
        active: string;
        inactive: string;
    };
};
export type NodeHint = {
    message: string;
    type?: 'info' | 'warning' | 'danger';
    location?: 'outputPane' | 'inputPane' | 'ndv';
    displayCondition?: string;
    whenToDisplay?: 'always' | 'beforeExecution' | 'afterExecution';
};
export type NodeExecutionHint = Omit<NodeHint, 'whenToDisplay' | 'displayCondition'>;
export interface INodeHookDescription {
    method: string;
}
export interface IWebhookData {
    httpMethod: IHttpRequestMethods;
    node: string;
    path: string;
    webhookDescription: IWebhookDescription;
    workflowId: string;
    workflowExecuteAdditionalData: IWorkflowExecuteAdditionalData;
    webhookId?: string;
    isTest?: boolean;
    userId?: string;
    staticData?: Workflow['staticData'];
}
export type WebhookType = 'default' | 'setup';
export interface IWebhookDescription {
    [key: string]: IHttpRequestMethods | WebhookResponseMode | boolean | string | undefined;
    httpMethod: IHttpRequestMethods | string;
    isFullPath?: boolean;
    name: WebhookType;
    path: string;
    responseBinaryPropertyName?: string;
    responseContentType?: string;
    responsePropertyName?: string;
    responseMode?: WebhookResponseMode | string;
    responseData?: WebhookResponseData | string;
    restartWebhook?: boolean;
    nodeType?: 'webhook' | 'form' | 'mcp';
    ndvHideUrl?: string | boolean;
    ndvHideMethod?: string | boolean;
}
export interface ProxyInput {
    all: () => INodeExecutionData[];
    context: any;
    first: () => INodeExecutionData | undefined;
    item: INodeExecutionData | undefined;
    last: () => INodeExecutionData | undefined;
    params?: INodeParameters;
}
export interface IWorkflowDataProxyData {
    [key: string]: any;
    $binary: INodeExecutionData['binary'];
    $data: any;
    $env: any;
    $evaluateExpression: (expression: string, itemIndex?: number) => NodeParameterValueType;
    $item: (itemIndex: number, runIndex?: number) => IWorkflowDataProxyData;
    $items: (nodeName?: string, outputIndex?: number, runIndex?: number) => INodeExecutionData[];
    $json: INodeExecutionData['json'];
    $node: any;
    $parameter: INodeParameters;
    $position: number;
    $workflow: any;
    $: any;
    $input: ProxyInput;
    $thisItem: any;
    $thisRunIndex: number;
    $thisItemIndex: number;
    $now: any;
    $today: any;
    $getPairedItem: (destinationNodeName: string, incomingSourceData: ISourceData | null, pairedItem: IPairedItemData) => INodeExecutionData | null;
    constructor: any;
}
export type IWorkflowDataProxyAdditionalKeys = IDataObject & {
    $execution?: {
        id: string;
        mode: 'test' | 'production';
        resumeUrl: string;
        resumeFormUrl: string;
        customData?: {
            set(key: string, value: string): void;
            setAll(obj: Record<string, string>): void;
            get(key: string): string;
            getAll(): Record<string, string>;
        };
    };
    $vars?: IDataObject;
    $secrets?: IDataObject;
    $pageCount?: number;
    /** @deprecated */
    $executionId?: string;
    /** @deprecated */
    $resumeWebhookUrl?: string;
};
export interface IWorkflowMetadata {
    id?: string;
    name?: string;
    active: boolean;
}
export interface IWebhookResponseData {
    workflowData?: INodeExecutionData[][];
    webhookResponse?: any;
    noWebhookResponse?: boolean;
}
export type WebhookResponseData = 'allEntries' | 'firstEntryJson' | 'firstEntryBinary' | 'noData';
/**
 * Defines how and when response should be sent:
 *
 * onReceived: Response is sent immidiatly after node done executing
 *
 * lastNode: Response is sent after the last node finishes executing
 *
 * responseNode: Response is sent from the Responde to Webhook node
 *
 * formPage: Special response with executionId sent to the form trigger node
 *
 * hostedChat: Special response with executionId sent to the hosted chat trigger node
 *
 * streaming: Response added to runData to httpResponse and streamingEnabled set to true
 */
export type WebhookResponseMode = 'onReceived' | 'lastNode' | 'responseNode' | 'formPage' | 'hostedChat' | 'streaming';
export interface INodeTypes {
    getByName(nodeType: string): INodeType | IVersionedNodeType;
    getByNameAndVersion(nodeType: string, version?: number): INodeType;
    getKnownTypes(): IDataObject;
}
export type LoadingDetails = {
    className: string;
    sourcePath: string;
};
export type CredentialLoadingDetails = LoadingDetails & {
    supportedNodes?: string[];
    extends?: string[];
};
export type NodeLoadingDetails = LoadingDetails;
export type KnownNodesAndCredentials = {
    nodes: Record<string, NodeLoadingDetails>;
    credentials: Record<string, CredentialLoadingDetails>;
};
export interface LoadedNodesAndCredentials {
    nodes: INodeTypeData;
    credentials: ICredentialTypeData;
}
export interface LoadedClass<T> {
    sourcePath: string;
    type: T;
}
type LoadedData<T> = Record<string, LoadedClass<T>>;
export type ICredentialTypeData = LoadedData<ICredentialType>;
export type INodeTypeData = LoadedData<INodeType | IVersionedNodeType>;
export interface IRun {
    data: IRunExecutionData;
    /**
     * @deprecated Use status instead
     */
    finished?: boolean;
    mode: WorkflowExecuteMode;
    waitTill?: Date | null;
    startedAt: Date;
    stoppedAt?: Date;
    status: ExecutionStatus;
    /** ID of the job this execution belongs to. Only in scaling mode. */
    jobId?: string;
}
export interface IRunExecutionData {
    startData?: {
        startNodes?: StartNodeData[];
        destinationNode?: string;
        originalDestinationNode?: string;
        runNodeFilter?: string[];
    };
    resultData: {
        error?: ExecutionError;
        runData: IRunData;
        pinData?: IPinData;
        lastNodeExecuted?: string;
        metadata?: Record<string, string>;
    };
    executionData?: {
        contextData: IExecuteContextData;
        nodeExecutionStack: IExecuteData[];
        metadata: {
            [key: string]: ITaskMetadata[];
        };
        waitingExecution: IWaitingForExecution;
        waitingExecutionSource: IWaitingForExecutionSource | null;
    };
    parentExecution?: RelatedExecution;
    /**
     * This is used to prevent breaking change
     * for waiting executions started before signature validation was added
     */
    validateSignature?: boolean;
    waitTill?: Date;
    pushRef?: string;
    /** Data needed for a worker to run a manual execution. */
    manualData?: Pick<IWorkflowExecutionDataProcess, 'dirtyNodeNames' | 'triggerToStartFrom' | 'userId'>;
}
export type SchemaType = 'string' | 'number' | 'boolean' | 'bigint' | 'symbol' | 'array' | 'object' | 'function' | 'null' | 'undefined';
export type Schema = {
    type: SchemaType;
    key?: string;
    value: string | Schema[];
    path: string;
};
export interface NodeExecutionSchema {
    nodeName: string;
    schema: Schema;
}
export interface IRunData {
    [key: string]: ITaskData[];
}
export interface ITaskSubRunMetadata {
    node: string;
    runIndex: number;
}
export interface RelatedExecution {
    executionId: string;
    workflowId: string;
    shouldResume?: boolean;
}
type SubNodeExecutionDataAction = {
    nodeName: string;
    runIndex: number;
    action: EngineRequest['actions'][number];
    response?: object;
};
export interface ITaskMetadata {
    subRun?: ITaskSubRunMetadata[];
    parentExecution?: RelatedExecution;
    subExecution?: RelatedExecution;
    subExecutionsCount?: number;
    subNodeExecutionData?: {
        actions: SubNodeExecutionDataAction[];
        metadata: object;
    };
    /**
     * When true, preserves sourceOverwrite information in pairedItem data during node execution.
     * This is used for AI tool nodes to maintain correct expression resolution context, allowing
     * tools to access data from nodes earlier in the workflow chain via $() expressions.
     */
    preserveSourceOverwrite?: boolean;
    /**
     * Indicates that this node execution is resuming from a previous pause (e.g., AI agent
     * resuming after tool execution). When true, the nodeExecuteBefore hook is skipped to
     * prevent duplicate event emissions that would cause UI state issues.
     * @see AI-1414
     */
    nodeWasResumed?: boolean;
}
/** The data that gets returned when a node execution starts */
export interface ITaskStartedData {
    startTime: number;
    /** This index tracks the order in which nodes are executed */
    executionIndex: number;
    source: Array<ISourceData | null>;
    hints?: NodeExecutionHint[];
}
/** The data that gets returned when a node execution ends */
export interface ITaskData extends ITaskStartedData {
    executionTime: number;
    executionStatus?: ExecutionStatus;
    data?: ITaskDataConnections;
    inputOverride?: ITaskDataConnections;
    error?: ExecutionError;
    metadata?: ITaskMetadata;
}
export interface ISourceData {
    previousNode: string;
    previousNodeOutput?: number;
    previousNodeRun?: number;
}
export interface StartNodeData {
    name: string;
    sourceData: ISourceData | null;
}
export interface ITaskDataConnections {
    [key: string]: Array<INodeExecutionData[] | null>;
}
export interface IWaitingForExecution {
    [key: string]: {
        [key: number]: ITaskDataConnections;
    };
}
export interface ITaskDataConnectionsSource {
    [key: string]: Array<ISourceData | null>;
}
export interface IWaitingForExecutionSource {
    [key: string]: {
        [key: number]: ITaskDataConnectionsSource;
    };
}
export type WorkflowId = IWorkflowBase['id'];
export interface IWorkflowBase {
    id: string;
    name: string;
    active: boolean;
    isArchived: boolean;
    createdAt: Date;
    startedAt?: Date;
    updatedAt: Date;
    nodes: INode[];
    connections: IConnections;
    settings?: IWorkflowSettings;
    staticData?: IDataObject;
    pinData?: IPinData;
    versionId?: string;
}
export interface IWorkflowCredentials {
    [credentialType: string]: {
        [id: string]: ICredentialsEncrypted;
    };
}
export interface IWorkflowExecutionDataProcess {
    destinationNode?: string;
    restartExecutionId?: string;
    executionMode: WorkflowExecuteMode;
    /**
     * The data that is sent in the body of the webhook that started this
     * execution.
     */
    executionData?: IRunExecutionData;
    runData?: IRunData;
    pinData?: IPinData;
    retryOf?: string | null;
    pushRef?: string;
    startNodes?: StartNodeData[];
    workflowData: IWorkflowBase;
    userId?: string;
    projectId?: string;
    dirtyNodeNames?: string[];
    triggerToStartFrom?: {
        name: string;
        data?: ITaskData;
    };
    agentRequest?: AiAgentRequest;
    httpResponse?: express.Response;
    streamingEnabled?: boolean;
    startedAt?: Date;
}
export interface ExecuteWorkflowOptions {
    node?: INode;
    parentWorkflowId: string;
    inputData?: INodeExecutionData[];
    loadedWorkflowData?: IWorkflowBase;
    loadedRunData?: IWorkflowExecutionDataProcess;
    parentWorkflowSettings?: IWorkflowSettings;
    parentCallbackManager?: CallbackManager;
    doNotWaitToFinish?: boolean;
    parentExecution?: RelatedExecution;
}
export type AiEvent = 'ai-messages-retrieved-from-memory' | 'ai-message-added-to-memory' | 'ai-output-parsed' | 'ai-documents-retrieved' | 'ai-document-reranked' | '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';
type AiEventPayload = {
    msg: string;
    workflowName: string;
    executionId: string;
    nodeName: string;
    workflowId?: string;
    nodeType?: string;
};
export interface AiAgentRequest {
    query: string | INodeParameters;
    tool: {
        name: string;
    };
}
export interface IWorkflowExecuteAdditionalData {
    credentialsHelper: ICredentialsHelper;
    executeWorkflow: (workflowInfo: IExecuteWorkflowInfo, additionalData: IWorkflowExecuteAdditionalData, options: ExecuteWorkflowOptions) => Promise<ExecuteWorkflowData>;
    getRunExecutionData: (executionId: string) => Promise<IRunExecutionData | undefined>;
    executionId?: string;
    restartExecutionId?: string;
    currentNodeExecutionIndex: number;
    httpResponse?: express.Response;
    httpRequest?: express.Request;
    streamingEnabled?: boolean;
    restApiUrl: string;
    instanceBaseUrl: string;
    setExecutionStatus?: (status: ExecutionStatus) => void;
    sendDataToUI?: (type: string, data: IDataObject | IDataObject[]) => void;
    formWaitingBaseUrl: string;
    webhookBaseUrl: string;
    webhookWaitingBaseUrl: string;
    webhookTestBaseUrl: string;
    currentNodeParameters?: INodeParameters;
    executionTimeoutTimestamp?: number;
    userId?: string;
    variables: IDataObject;
    logAiEvent: (eventName: AiEvent, payload: AiEventPayload) => void;
    parentCallbackManager?: CallbackManager;
    startRunnerTask<T, E = unknown>(additionalData: IWorkflowExecuteAdditionalData, jobType: string, settings: unknown, executeFunctions: IExecuteFunctions, inputData: ITaskDataConnections, node: INode, workflow: Workflow, runExecutionData: IRunExecutionData, runIndex: number, itemIndex: number, activeNodeName: string, connectionInputData: INodeExecutionData[], siblingParameters: INodeParameters, mode: WorkflowExecuteMode, envProviderState: EnvProviderState, executeData?: IExecuteData): Promise<Result<T, E>>;
}
export type WorkflowExecuteMode = 'cli' | 'error' | 'integrated' | 'internal' | 'manual' | 'retry' | 'trigger' | 'webhook' | 'evaluation';
export type WorkflowActivateMode = 'init' | 'create' | 'update' | 'activate' | 'manual' | 'leadershipChange';
export declare namespace WorkflowSettings {
    type CallerPolicy = 'any' | 'none' | 'workflowsFromAList' | 'workflowsFromSameOwner';
    type SaveDataExecution = 'DEFAULT' | 'all' | 'none';
}
export interface IWorkflowSettings {
    timezone?: 'DEFAULT' | string;
    errorWorkflow?: string;
    callerIds?: string;
    callerPolicy?: WorkflowSettings.CallerPolicy;
    saveDataErrorExecution?: WorkflowSettings.SaveDataExecution;
    saveDataSuccessExecution?: WorkflowSettings.SaveDataExecution;
    saveManualExecutions?: 'DEFAULT' | boolean;
    saveExecutionProgress?: 'DEFAULT' | boolean;
    executionTimeout?: number;
    executionOrder?: 'v0' | 'v1';
    timeSavedPerExecution?: number;
    availableInMCP?: boolean;
}
export interface WorkflowFEMeta {
    onboardingId?: string;
}
export interface WorkflowTestData {
    description: string;
    input: {
        workflowData: {
            nodes: INode[];
            connections: IConnections;
            settings?: IWorkflowSettings;
        };
    };
    output: {
        assertBinaryData?: boolean;
        nodeExecutionOrder?: string[];
        nodeExecutionStack?: IExecuteData[];
        testAllOutputs?: boolean;
        nodeData: {
            [key: string]: any[][];
        };
        error?: string;
    };
    nock?: {
        baseUrl: string;
        mocks: Array<{
            method: 'delete' | 'get' | 'patch' | 'post' | 'put';
            path: string;
            requestBody?: RequestBodyMatcher;
            requestHeaders?: Record<string, RequestHeaderMatcher>;
            statusCode: number;
            responseBody: string | object;
            responseHeaders?: ReplyHeaders;
        }>;
    };
    trigger?: {
        mode: WorkflowExecuteMode;
        input: INodeExecutionData;
    };
    credentials?: Record<string, ICredentialDataDecryptedObject>;
}
export type LogLevel = (typeof LOG_LEVELS)[number];
export type LogMetadata = {
    [key: string]: unknown;
    scopes?: LogScope[];
    file?: string;
    function?: string;
};
export type Logger = Record<Exclude<LogLevel, 'silent'>, (message: string, metadata?: LogMetadata) => void>;
export type LogLocationMetadata = Pick<LogMetadata, 'file' | 'function'>;
export interface IStatusCodeMessages {
    [key: string]: string;
}
export type DocumentationLink = {
    url: string;
};
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]: Array<NodeParameterValue | DisplayCondition> | undefined;
        };
    };
}>;
export interface ITelemetryTrackProperties {
    user_id?: string;
    [key: string]: GenericValue;
}
export interface INodesGraph {
    node_types: string[];
    node_connections: IDataObject[];
    nodes: INodesGraphNode;
    notes: INotesGraphNode;
    is_pinned: boolean;
}
export interface INodesGraphNode {
    [key: string]: INodeGraphItem;
}
export interface INotesGraphNode {
    [key: string]: INoteGraphItem;
}
export interface INoteGraphItem {
    overlapping: boolean;
    position: [number, number];
    height: number;
    width: number;
}
export interface INodeGraphItem {
    id: string;
    type: string;
    version?: number;
    resource?: string;
    operation?: string;
    domain?: string;
    domain_base?: string;
    domain_path?: string;
    position: [number, number];
    mode?: string;
    credential_type?: string;
    credential_set?: boolean;
    method?: string;
    src_node_id?: string;
    src_instance_id?: string;
    agent?: string;
    is_streaming?: boolean;
    prompts?: IDataObject[] | IDataObject;
    toolSettings?: IDataObject;
    sql?: string;
    workflow_id?: string;
    response_mode?: string;
    public_chat?: boolean;
    runs?: number;
    items_total?: number;
    metric_names?: string[];
    language?: string;
    package_version?: string;
}
export interface INodeNameIndex {
    [name: string]: string;
}
export interface INodesGraphResult {
    nodeGraph: INodesGraph;
    nameIndices: INodeNameIndex;
    webhookNodeNames: string[];
    evaluationTriggerNodeNames: string[];
}
export interface FeatureFlags {
    [featureFlag: string]: string | boolean | undefined;
}
export interface IConnectedNode {
    name: string;
    indicies: number[];
    depth: number;
}
export type PublicInstalledPackage = {
    packageName: string;
    installedVersion: string;
    authorName?: string;
    authorEmail?: string;
    installedNodes: PublicInstalledNode[];
    createdAt: Date;
    updatedAt: Date;
    updateAvailable?: string;
    failedLoading?: boolean;
};
export type PublicInstalledNode = {
    name: string;
    type: string;
    latestVersion: number;
    package: PublicInstalledPackage;
};
export interface NodeExecutionWithMetadata extends INodeExecutionData {
    pairedItem: IPairedItemData | IPairedItemData[];
}
export type AnnotationVote = 'up' | 'down';
export interface ExecutionSummary {
    id: string;
    /**
     * @deprecated Use status instead
     */
    finished?: boolean;
    mode: WorkflowExecuteMode;
    retryOf?: string | null;
    retrySuccessId?: string | null;
    waitTill?: Date;
    createdAt: Date;
    startedAt: Date | null;
    stoppedAt?: Date;
    workflowId: string;
    workflowName?: string;
    status: ExecutionStatus;
    lastNodeExecuted?: string;
    executionError?: ExecutionError;
    nodeExecutionStatus?: {
        [key: string]: IExecutionSummaryNodeExecutionResult;
    };
    annotation?: {
        vote: AnnotationVote;
        tags: Array<{
            id: string;
            name: string;
        }>;
    };
}
export interface IExecutionSummaryNodeExecutionResult {
    executionStatus: ExecutionStatus;
    errors?: Array<{
        name?: string;
        message?: string;
        description?: string;
    }>;
}
export interface ResourceMapperFields {
    fields: ResourceMapperField[];
    emptyFieldsNotice?: string;
}
export interface WorkflowInputsData {
    fields: ResourceMapperField[];
    dataMode: string;
    subworkflowInfo?: {
        workflowId?: string;
        triggerId?: 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 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;
    limitSelection?: 'exact' | 'range' | 'unlimited';
    numberOfSelections?: number;
    minSelections?: number;
    maxSelections?: number;
}>;
export type FieldTypeMap = {
    boolean: boolean;
    number: number;
    string: string;
    'string-alphanumeric': string;
    dateTime: string;
    time: string;
    array: unknown[];
    object: object;
    options: any;
    url: string;
    jwt: string;
    'form-fields': FormFieldsParameter;
};
export type FieldType = keyof FieldTypeMap;
export type ValidationResult<T extends FieldType = FieldType> = {
    valid: false;
    errorMessage: string;
} | {
    valid: true;
    newValue?: FieldTypeMap[T];
};
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 FilterConditionValue = {
    id: string;
    leftValue: NodeParameterValue | NodeParameterValue[];
    operator: FilterOperatorValue;
    rightValue: NodeParameterValue | NodeParameterValue[];
};
export type FilterOptionsValue = {
    caseSensitive: boolean;
    leftValue: string;
    typeValidation: 'strict' | 'loose';
    version: 1 | 2;
};
export type FilterValue = {
    options: FilterOptionsValue;
    conditions: FilterConditionValue[];
    combinator: FilterTypeCombinator;
};
export type AssignmentCollectionValue = {
    assignments: AssignmentValue[];
};
export type AssignmentValue = {
    id: string;
    name: string;
    value: NodeParameterValue;
    type?: string;
};
export interface ExecutionOptions {
    limit?: number;
}
export interface ExecutionFilters {
    /**
     * @deprecated Use status instead
     */
    finished?: boolean;
    mode?: WorkflowExecuteMode[];
    retryOf?: string;
    retrySuccessId?: string;
    status?: ExecutionStatus[];
    waitTill?: boolean;
    workflowId?: number | string;
}
export type NpsSurveyRespondedState = {
    lastShownAt: number;
    responded: true;
};
export type NpsSurveyWaitingState = {
    lastShownAt: number;
    waitingForResponse: true;
    ignoredCount: number;
};
export type NpsSurveyState = NpsSurveyRespondedState | NpsSurveyWaitingState;
export interface IUserSettings {
    isOnboarded?: boolean;
    firstSuccessfulWorkflowId?: string;
    userActivated?: boolean;
    userActivatedAt?: number;
    allowSSOManualLogin?: boolean;
    npsSurvey?: NpsSurveyState;
    easyAIWorkflowOnboarded?: boolean;
    userClaimedAiCredits?: boolean;
    dismissedCallouts?: Record<string, boolean>;
}
export interface IProcessedDataConfig {
    availableModes: string;
    mode: string;
}
export interface IDataDeduplicator {
    checkProcessedAndRecord(items: DeduplicationItemTypes[], context: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<IDeduplicationOutput>;
    removeProcessed(items: DeduplicationItemTypes[], context: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<void>;
    clearAllProcessedItems(context: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<void>;
    getProcessedDataCount(context: DeduplicationScope, contextData: ICheckProcessedContextData, options: ICheckProcessedOptions): Promise<number>;
}
export interface ICheckProcessedContextData {
    node?: INode;
    workflow: {
        id: string;
        active: boolean;
    };
}
export type N8nAIProviderType = 'openai' | 'unknown';
export type Functionality = 'regular' | 'configuration-node' | 'pairedItem';
export type CallbackManager = CallbackManagerLC;
export type IPersonalizationSurveyAnswersV4 = {
    version: 'v4';
    personalization_survey_submitted_at: string;
    personalization_survey_n8n_version: string;
    automationGoalDevops?: string[] | null;
    automationGoalDevopsOther?: string | null;
    companyIndustryExtended?: string[] | null;
    otherCompanyIndustryExtended?: string[] | null;
    companySize?: string | null;
    companyType?: string | null;
    automationGoalSm?: string[] | null;
    automationGoalSmOther?: string | null;
    usageModes?: string[] | null;
    email?: string | null;
    role?: string | null;
    roleOther?: string | null;
    reportedSource?: string | null;
    reportedSourceOther?: string | null;
};
export type ChunkType = 'begin' | 'item' | 'end' | 'error';
export interface StructuredChunk {
    type: ChunkType;
    content?: string;
    metadata: {
        nodeId: string;
        nodeName: string;
        runIndex: number;
        itemIndex: number;
        timestamp: number;
    };
}
export type ApiKeyAudience = 'public-api' | 'mcp-server-api';
export {};
//# sourceMappingURL=interfaces.d.ts.map