/**
 * Ultra-Advanced Dependency Graph System for CLI Analyzers
 * Handles complex dependency resolution, circular detection, memory optimization, and conditional execution
 */
import type { SectionResultMap, DependencyResolver, CLIOptions } from './types';
import type { LogContext } from '../utils/logger';
/**
 * Execution plan for dependency resolution
 */
export interface ExecutionPlan {
    order: string[];
    memoryOptimized: boolean;
    conditionalSkips: string[];
    parallelGroups: string[][];
    estimatedMemoryPeak: number;
}
/**
 * Advanced dependency graph with topological sorting, cycle detection, and memory optimization
 */
export declare class DependencyGraph {
    private nodes;
    private resolved;
    private resolving;
    private executionHistory;
    private memoryThreshold;
    constructor(memoryThreshold?: number);
    /**
     * Initialize the default section dependency graph
     */
    private initializeDefaultNodes;
    /**
     * Add a node to the dependency graph
     */
    addNode(id: string, dependencies?: string[], optional?: boolean, weight?: number, condition?: (options: CLIOptions) => boolean): void;
    /**
     * Detect circular dependencies using DFS
     */
    detectCircularDependencies(): {
        hasCircles: boolean;
        cycles: string[][];
    };
    /**
     * Generate optimal execution plan using modified Kahn's algorithm with memory optimization
     */
    generateExecutionPlan(requestedSections: string[], options: CLIOptions): ExecutionPlan;
    /**
     * Expand requested sections to include all required dependencies
     */
    private expandDependencies;
    /**
     * Topological sort using Kahn's algorithm with memory-aware ordering
     */
    private topologicalSort;
    /**
     * Select next node for execution based on memory optimization
     */
    private selectNextNode;
    /**
     * Calculate optimization score for node selection
     */
    private calculateNodeScore;
    /**
     * Insert node into queue maintaining sorted order by weight
     */
    private insertSorted;
    /**
     * Identify sections that can execute in parallel
     */
    private identifyParallelGroups;
    /**
     * Check if execution order is memory optimized
     */
    private isMemoryOptimized;
    /**
     * Estimate peak memory usage for execution plan
     */
    private estimateMemoryPeak;
    /**
     * Record execution time for future optimization
     */
    recordExecutionTime(sectionId: string, timeMs: number): void;
    /**
     * Get dependency graph visualization for debugging
     */
    getGraphVisualization(): string;
    /**
     * Validate specific dependency requirements
     */
    validateDependencies(requestedSections: string[]): {
        isValid: boolean;
        errors: string[];
        warnings: string[];
    };
}
/**
 * Concrete implementation of dependency resolver with caching and validation
 */
export declare class AnalyzerDependencyResolver implements DependencyResolver {
    private dependencies;
    private resolverFunctions;
    private context;
    private dependencyGraph;
    private currentExecutionPlan?;
    private options;
    constructor(context?: LogContext, options?: CLIOptions);
    /**
     * Generate optimal execution plan for requested sections
     */
    planExecution(requestedSections: string[]): ExecutionPlan;
    /**
     * Get current execution plan
     */
    getExecutionPlan(): ExecutionPlan | undefined;
    /**
     * Check if parallel execution is possible for given sections
     */
    canExecuteInParallel(sectionA: string, sectionB: string): boolean;
    /**
     * Register resolver function for a section
     */
    registerResolver<K extends keyof SectionResultMap>(sectionName: K, resolver: () => Promise<SectionResultMap[K]>): void;
    /**
     * Resolve a specific section dependency with error handling and performance tracking
     */
    resolve<K extends keyof SectionResultMap>(sectionName: K): Promise<SectionResultMap[K]>;
    /**
     * Calculate adaptive timeout based on historical execution data
     */
    private calculateTimeoutForSection;
    /**
     * Execute resolver with timeout protection
     */
    private executeWithTimeout;
    /**
     * Validate that a section result has the expected structure
     */
    private validateSectionResult;
    /**
     * Get validation rules for a specific section
     */
    private getSectionValidationRules;
    /**
     * Check if object has a property using safe property access
     */
    private hasProperty;
    /**
     * Cache a section result with metadata
     */
    cache<K extends keyof SectionResultMap>(sectionName: K, result: SectionResultMap[K]): void;
    /**
     * Clear all cached dependencies
     */
    clear(): void;
    /**
     * Check if a section is already cached
     */
    has(sectionName: string): boolean;
    /**
     * Get all cached section names
     */
    getCachedSections(): string[];
    /**
     * Get dependency resolution statistics
     */
    getStats(): {
        totalCached: number;
        cachedSections: string[];
        oldestCache?: Date;
        newestCache?: Date;
    };
    /**
     * Resolve multiple dependencies using optimal execution plan
     */
    resolveMultiple<K extends keyof SectionResultMap>(sectionNames: K[]): Promise<Record<K, SectionResultMap[K]>>;
    /**
     * Execute sections in parallel groups for optimal performance
     */
    private executeParallelPlan;
    /**
     * Execute sections sequentially using optimal order
     */
    private executeSequentialPlan;
    /**
     * Perform just-in-time memory cleanup of cached results
     */
    private performJustInTimeCleanup;
    /**
     * Get the recommended resolution order for given sections using dependency graph
     */
    getResolutionOrder(sectionNames: string[]): string[];
    /**
     * Check if all dependencies for a section are available
     */
    canResolve(sectionName: string): {
        canResolve: boolean;
        missingDependencies: string[];
    };
    /**
     * Get detailed dependency information with graph insights
     */
    getDependencyInsights(): {
        graphVisualization: string;
        executionStats: any;
        memoryOptimization: boolean;
        recommendations: string[];
    };
    /**
     * Validate execution readiness for given sections
     */
    validateExecutionReadiness(sectionNames: string[]): {
        ready: boolean;
        issues: string[];
        warnings: string[];
        executionPlan?: ExecutionPlan;
    };
    /**
     * Access dependency graph for advanced operations
     */
    getDependencyGraph(): DependencyGraph;
}
/**
 * Factory function to create a configured dependency resolver with enhanced features
 */
export declare function createDependencyResolver(filePath: string, options: CLIOptions, context?: LogContext): AnalyzerDependencyResolver;
/**
 * Enhanced dependency chain validator that leverages the new dependency graph system
 * @deprecated Use DependencyGraph directly for more advanced features
 */
export declare class DependencyChainValidator {
    private dependencyGraph;
    constructor(options?: CLIOptions);
    /**
     * Validate that all dependencies can be resolved for the given sections
     */
    validateChain(requestedSections: string[]): {
        isValid: boolean;
        errors: string[];
        warnings: string[];
    };
    /**
     * Get the optimal execution order for the given sections
     */
    getExecutionOrder(requestedSections: string[], options?: CLIOptions): string[];
    /**
     * Get advanced execution plan with memory optimization and parallel groups
     */
    getAdvancedExecutionPlan(requestedSections: string[], options?: CLIOptions): ExecutionPlan;
    /**
     * Check for circular dependencies
     */
    checkCircularDependencies(): {
        hasCircles: boolean;
        cycles: string[][];
    };
    /**
     * Get dependency graph visualization
     */
    getGraphVisualization(): string;
}
/**
 * Create a dependency resolver with pre-configured analyzers for common use cases
 */
export declare function createConfiguredDependencyResolver(filePath: string, options: CLIOptions, context?: LogContext): {
    resolver: AnalyzerDependencyResolver;
    executionPlan: ExecutionPlan | null;
    insights: any;
};
/**
 * Utility function to validate section dependencies without creating a resolver
 */
export declare function validateSectionDependencies(requestedSections: string[], options?: CLIOptions): {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    recommendedOrder: string[];
    memoryEstimate: number;
};
//# sourceMappingURL=dependency-resolver.d.ts.map