import type { DtsGenerationConfig } from './types';
/**
 * Build dependency graph from source files
 */
export declare function buildProcessingGraph(files: string[], rootDir?: string): Promise<Map<string, ProcessingNode>>;
/**
 * Process files in parallel respecting dependencies
 */
export declare function processInParallel(files: string[], options?: ParallelProcessorConfig): Promise<ParallelProcessingResult>;
/**
 * Get topological processing order (respects dependencies)
 */
export declare function getTopologicalOrder(graph: Map<string, ProcessingNode>): string[];
/**
 * Find files that can be processed independently (no dependencies on other files in the set)
 */
export declare function findIndependentFiles(graph: Map<string, ProcessingNode>): string[];
/**
 * Get processing levels (files at same level can be processed in parallel)
 */
export declare function getProcessingLevels(graph: Map<string, ProcessingNode>): string[][];
/**
 * Analyze graph for parallelization potential
 */
export declare function analyzeParallelizationPotential(graph: Map<string, ProcessingNode>): {
    totalFiles: number
    independentFiles: number
    maxParallelism: number
    levels: number
    estimatedSpeedup: number
  };
/**
 * Node in the processing dependency graph
 */
export declare interface ProcessingNode {
  path: string
  dependencies: Set<string>
  dependents: Set<string>
  state: 'pending' | 'processing' | 'completed' | 'failed'
  result?: string
  error?: Error
  duration?: number
}
/**
 * Configuration for parallel processing
 */
export declare interface ParallelProcessorConfig {
  maxConcurrency?: number
  rootDir?: string
  config?: Partial<DtsGenerationConfig>
  onProgress?: (completed: number, total: number, current: string) => void
  onError?: (path: string, error: Error) => boolean
}
/**
 * Result of parallel processing
 */
export declare interface ParallelProcessingResult {
  success: Map<string, string>
  failed: Map<string, Error>
  totalTimeMs: number
  maxConcurrent: number
  processingOrder: string[]
}