import type { ExecutionBaseError, ExecutionStorageLocation, IConnection, IExecuteData, INode, INodeExecutionData, IPinData, IRun, IRunData, ITaskMetadata, Workflow, IRunExecutionData, IWorkflowExecuteAdditionalData, WorkflowExecuteMode, IRunNodeResponse, IWorkflowIssues, AiAgentRequest, IWorkflowExecutionDataProcess, EngineRequest, EngineResponse, IDestinationNode } from 'n8n-workflow';
import PCancelable from 'p-cancelable';
interface RunWorkflowOptions {
    workflow: Workflow;
    startNode?: INode;
    destinationNode?: IDestinationNode;
    pinData?: IPinData;
    triggerToStartFrom?: IWorkflowExecutionDataProcess['triggerToStartFrom'];
    additionalRunFilterNodes?: string[];
}
export declare class WorkflowExecute {
    private readonly additionalData;
    private readonly mode;
    private runExecutionData;
    private readonly storedAt;
    private status;
    private readonly abortController;
    timedOut: boolean;
    constructor(additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, runExecutionData?: IRunExecutionData, storedAt?: ExecutionStorageLocation);
    run({ workflow, startNode, destinationNode, pinData, triggerToStartFrom, additionalRunFilterNodes, }: RunWorkflowOptions): PCancelable<IRun>;
    isLegacyExecutionOrder(workflow: Workflow): boolean;
    runPartialWorkflow2(workflow: Workflow, runData: IRunData, pinData: IPinData | undefined, dirtyNodeNames: string[] | undefined, destinationNode: IDestinationNode, agentRequest?: AiAgentRequest): PCancelable<IRun>;
    moveNodeMetadata(): void;
    incomingConnectionIsEmpty(runData: IRunData, inputConnections: IConnection[], runIndex: number): boolean;
    prepareWaitingToExecution(nodeName: string, numberOfConnections: number, runIndex: number): void;
    addNodeToBeExecuted(workflow: Workflow, connectionData: IConnection, outputIndex: number, parentNodeName: string, nodeSuccessData: INodeExecutionData[][], runIndex: number, newRunIndex?: number, metadata?: ITaskMetadata): void;
    checkReadyForExecution(workflow: Workflow, inputData?: {
        startNode?: string;
        destinationNode?: IDestinationNode;
        pinDataNodeNames?: string[];
    }): IWorkflowIssues | null;
    private getCustomOperation;
    private handleDisabledNode;
    private prepareConnectionInputData;
    private rethrowLastNodeError;
    private handleExecuteOnce;
    private executeNode;
    private executePollNode;
    private executeTriggerNode;
    private executeDeclarativeNodeInTest;
    runNode(workflow: Workflow, executionData: IExecuteData, runExecutionData: IRunExecutionData, runIndex: number, additionalData: IWorkflowExecuteAdditionalData, mode: WorkflowExecuteMode, abortSignal?: AbortSignal, subNodeExecutionResults?: EngineResponse): Promise<IRunNodeResponse | EngineRequest>;
    private handleWaitingState;
    private checkForWorkflowIssues;
    private setupExecution;
    private handleEngineRequest;
    processRunExecutionData(workflow: Workflow): PCancelable<IRun>;
    ensureInputData(workflow: Workflow, executionNode: INode, executionData: IExecuteData): boolean;
    processSuccessExecution(startedAt: Date, workflow: Workflow, executionError?: ExecutionBaseError, closeFunction?: Promise<void>): Promise<IRun>;
    getFullRunData(startedAt: Date, stoppedAt?: Date): IRun;
    handleNodeErrorOutput(workflow: Workflow, executionData: IExecuteData, nodeSuccessData: INodeExecutionData[][], runIndex: number): void;
    assignPairedItems(nodeSuccessData: INodeExecutionData[][] | null | undefined, executionData: IExecuteData): INodeExecutionData[][] | null;
    private updateTaskStatusesToCancelled;
    private get isCancelled();
}
export {};