import type { Plugin } from "../../plugin";
import type { ProviderAdapter } from "../../providers/adapter";
import type { ProcessOptions, ProcessResult, PricingConfig } from "../../types";
import PQueue from "p-queue";
import { ProgressTracker } from "./progress-tracker";
import type { ExecutionPlan, ProcessState } from "../shared/types";
interface ExecutionConfig {
    concurrency: number;
    maxRetries: number;
    retryDelay: number;
    continueOnError: boolean;
    timeout: number;
    dimensionTimeouts: Record<string, number>;
    pricing?: PricingConfig;
}
export declare class PhaseExecutor {
    private readonly plugin;
    private readonly adapter;
    readonly config: ExecutionConfig;
    private readonly graphManager;
    private readonly costCalculator?;
    private readonly queue;
    private originalSectionResults?;
    private readonly dependencyResolver;
    private readonly transformationManager;
    private hookExecutor?;
    private providerExecutor?;
    private dimensionExecutor?;
    private progressTracker?;
    private progressDisplay?;
    constructor(plugin: Plugin, adapter: ProviderAdapter, config: ExecutionConfig);
    getPlugin(): Plugin;
    preProcess(state: ProcessState, options: ProcessOptions): Promise<void>;
    planExecution(state: ProcessState): Promise<ExecutionPlan>;
    /**
     * Phase 3: Execution
     *
     * Executes all dimensions according to the execution plan.
     * Processes dimensions in parallel groups, respecting dependencies.
     */
    executeDimensions(state: ProcessState, plan: ExecutionPlan, options: ProcessOptions): Promise<void>;
    executeGlobalDimensions(dimensions: string[], state: ProcessState, dependencyGraph: Record<string, string[]>, options: ProcessOptions): Promise<void>;
    /**
     * Executes section dimensions across all sections
     */
    executeSectionDimensions(dimensions: string[], state: ProcessState, dependencyGraph: Record<string, string[]>, options: ProcessOptions): Promise<void>;
    finalizeResults(state: ProcessState): Promise<ProcessResult>;
    postProcess(state: ProcessState, result: ProcessResult, plan: ExecutionPlan): Promise<ProcessResult>;
    handleFailure(state: ProcessState, error: unknown): Promise<ProcessResult>;
    private initializeExecutors;
    private aggregateAllResults;
    private resolveProgressDisplay;
    getProgressTracker(): ProgressTracker | undefined;
    getQueue(): PQueue;
}
export {};
//# sourceMappingURL=phase-executor.d.ts.map