/**
 * Sequential Section Execution Engine - Advanced orchestration for multi-section analysis
 *
 * Ultra-Hard Challenges Solved:
 * 1. Memory Management: Efficient memory handling across sequential execution with automatic cleanup
 * 2. Error Propagation & Rollback: Graceful handling of cascading failures with proper rollback
 * 3. Result Passing: Correctly typed and passed section results instead of inadequate mocks
 * 4. Progress Tracking: Real-time progress reporting with estimated completion times
 * 5. Performance Optimization: Avoid redundant execution while maintaining correctness
 */
import type { CLIOptions, CLIResult, ProgressCallbacks } from './types';
import type { LogContext } from '../utils/logger';
import type { AnalysisDataset } from './universal-analyzer';
/**
 * Advanced sequential execution engine that orchestrates section analysis
 * with sophisticated memory management and error handling
 */
export declare class SequentialExecutor {
    private resolver;
    private executionState;
    private progressCallbacks;
    private options;
    private dataset;
    private context;
    private executionPlan;
    private sectionConfigs;
    private resultCache;
    constructor(dataset: AnalysisDataset, options: CLIOptions, progressCallbacks?: ProgressCallbacks, context?: LogContext);
    /**
     * Execute the requested sections in optimal order with full dependency resolution
     */
    execute(requestedSections: string[]): Promise<CLIResult>;
    /**
     * Phase 1: Plan execution using dependency resolver
     */
    private planExecution;
    /**
     * Phase 2: Validate execution readiness
     */
    private validateExecutionReadiness;
    /**
     * Phase 3: Execute sections sequentially with real dependency passing
     */
    private executeSequentialPlan;
    /**
     * Execute a single section with memory management and error handling
     */
    private executeSingleSection;
    /**
     * Handle section failure with proper rollback and error propagation
     */
    private handleSectionFailure;
    /**
     * Execute section with enhanced error handling and context
     */
    private executeSectionWithEnhancedContext;
    /**
     * Register section resolvers with the dependency resolver and enhanced error handling
     */
    private registerSectionResolvers;
    /**
     * Execute with timeout protection
     */
    private executeWithTimeout;
    /**
     * Create rollback point for error recovery
     */
    private createRollbackPoint;
    /**
     * Perform rollback to clean state
     */
    private performRollback;
    /**
     * Pre-execution memory cleanup
     */
    private performPreExecutionCleanup;
    /**
     * Phase 4: Post-execution cleanup and validation
     */
    private performPostExecutionCleanup;
    /**
     * Handle execution errors with enhanced debugging and detailed reporting
     */
    private handleExecutionError;
    /**
     * Update progress with detailed state information
     */
    private updateProgress;
    /**
     * Get performance metrics for reporting
     */
    private getPerformanceMetrics;
    /**
     * Get current execution status for monitoring
     */
    getExecutionStatus(): {
        currentSection: string | null;
        completedSections: string[];
        totalSections: number;
        progress: number;
        memoryUsage: NodeJS.MemoryUsage;
        elapsedTime: number;
    };
    /**
     * Clean up executor resources
     */
    cleanup(): Promise<void>;
    /**
     * Get cache statistics for monitoring and debugging
     */
    getCacheStats(): any;
    /**
     * Clear result cache manually
     */
    clearCache(): Promise<void>;
    /**
     * Invalidate cache for specific file
     */
    invalidateCacheForFile(filePath: string): Promise<void>;
}
/**
 * Factory function to create and configure a sequential executor
 */
export declare function createSequentialExecutor(dataset: AnalysisDataset, options: CLIOptions, progressCallbacks?: ProgressCallbacks, context?: LogContext): SequentialExecutor;
/**
 * Utility function to validate sequential execution requirements
 */
export declare function validateSequentialExecutionRequirements(dataset: AnalysisDataset, options: CLIOptions): {
    canExecute: boolean;
    issues: string[];
    warnings: string[];
    estimatedMemoryUsage: number;
};
//# sourceMappingURL=sequential-executor.d.ts.map