import { Logger } from '@n8n/backend-common';
import { ExecutionsConfig } from '@n8n/config';
import { ExecutionRepository } from '@n8n/db';
import type { IDeferredPromise } from '@n8n/utils/promise/deferred-promise';
import type { ExecutionLifecycleHooks } from 'n8n-core';
import { ErrorReporter, InstanceSettings, StorageConfig } from 'n8n-core';
import type { ExecutionError, IExecuteResponsePromiseData, INode, WorkflowExecuteMode, IWorkflowExecutionDataProcess } from 'n8n-workflow';
import { Workflow } from 'n8n-workflow';
import { EventService } from './events/event.service';
import { ActiveExecutions } from './active-executions';
import { ExecutionNotFoundError } from './errors/execution-not-found-error';
import { ExecutionPersistence } from './executions/execution-persistence';
import { FailedRunFactory } from './executions/failed-run-factory';
import { CredentialsPermissionChecker, WorkflowPreExecute } from './executions/pre-execution-checks';
import { ExternalHooks } from './external-hooks';
import type { ResumableExecution } from './interfaces';
import { ManualExecutionService } from './manual-execution.service';
import { NodeTypes } from './node-types';
import { EngineV2Dispatcher } from './services/engine-v2-dispatcher.service';
import { WorkflowStaticDataService } from './workflows/workflow-static-data.service';
export declare class WorkflowRunner {
    private readonly logger;
    private readonly errorReporter;
    private readonly activeExecutions;
    private readonly executionRepository;
    private readonly executionPersistence;
    private readonly workflowStaticDataService;
    private readonly nodeTypes;
    private readonly credentialsPermissionChecker;
    private readonly instanceSettings;
    private readonly manualExecutionService;
    private readonly failedRunFactory;
    private readonly eventService;
    private readonly executionsConfig;
    private readonly storageConfig;
    private readonly externalHooks;
    private readonly engineV2Dispatcher;
    private readonly workflowPreExecute;
    private scalingService;
    private poolConfigService;
    constructor(logger: Logger, errorReporter: ErrorReporter, activeExecutions: ActiveExecutions, executionRepository: ExecutionRepository, executionPersistence: ExecutionPersistence, workflowStaticDataService: WorkflowStaticDataService, nodeTypes: NodeTypes, credentialsPermissionChecker: CredentialsPermissionChecker, instanceSettings: InstanceSettings, manualExecutionService: ManualExecutionService, failedRunFactory: FailedRunFactory, eventService: EventService, executionsConfig: ExecutionsConfig, storageConfig: StorageConfig, externalHooks: ExternalHooks, engineV2Dispatcher: EngineV2Dispatcher, workflowPreExecute: WorkflowPreExecute);
    processError(error: ExecutionError | ExecutionNotFoundError, startedAt: Date, executionMode: WorkflowExecuteMode, executionId: string, hooks?: ExecutionLifecycleHooks): Promise<void>;
    private failExecution;
    establishContextForPersistence(data: IWorkflowExecutionDataProcess): Promise<(ExecutionError & {
        node?: INode;
    }) | undefined>;
    run(data: IWorkflowExecutionDataProcess, loadStaticData?: boolean, realtime?: boolean, existingExecution?: ResumableExecution, responsePromise?: IDeferredPromise<IExecuteResponsePromiseData>): Promise<string>;
    private resolvePinData;
    prepareNewExecution(data: IWorkflowExecutionDataProcess, loadStaticData?: boolean): Promise<Workflow | undefined>;
    private runMainProcess;
    private enqueueExecution;
    private needsFullExecutionData;
}