/**
 * Agentic QE v3 - Coverage Router for RuVector Integration
 *
 * Uses RuVector's ML capabilities for coverage-aware agent routing.
 * Falls back to rule-based routing when RuVector is unavailable.
 */
import type { CoverageRouter, CoverageRoutingResult, FileCoverage, CoverageGap, RuVectorConfig } from './interfaces';
/**
 * Coverage thresholds for routing decisions
 */
export interface CoverageThresholds {
    /** Target line coverage */
    lineCoverage: number;
    /** Target branch coverage */
    branchCoverage: number;
    /** Target function coverage */
    functionCoverage: number;
    /** Critical threshold (below this is critical priority) */
    criticalThreshold: number;
    /** High threshold (below this is high priority) */
    highThreshold: number;
    /** Medium threshold (below this is medium priority) */
    mediumThreshold: number;
}
/**
 * Coverage router that integrates with RuVector
 * Provides ML-enhanced coverage analysis and agent routing
 */
export declare class RuVectorCoverageRouter implements CoverageRouter {
    private readonly config;
    private readonly fallback;
    private readonly thresholds;
    private readonly cache;
    constructor(config: RuVectorConfig, thresholds?: Partial<CoverageThresholds>);
    /**
     * Analyze coverage and route agents
     */
    analyzeCoverage(coverageData: FileCoverage[], targetCoverage?: number): Promise<CoverageRoutingResult>;
    /**
     * Get coverage gaps
     */
    getCoverageGaps(coverageData: FileCoverage[]): Promise<CoverageGap[]>;
    /**
     * Prioritize files for coverage improvement
     */
    prioritizeForCoverage(files: string[], coverageData: FileCoverage[]): Promise<string[]>;
    /**
     * Suggest tests to improve coverage
     */
    suggestTestsForCoverage(filePath: string, coverage: FileCoverage): Promise<Array<{
        testType: string;
        target: string;
        expectedCoverageGain: number;
    }>>;
    /**
     * Perform coverage analysis and routing
     */
    private performAnalysis;
    /**
     * Analyze line coverage gaps
     */
    private analyzeLineCoverageGaps;
    /**
     * Analyze branch coverage gaps
     */
    private analyzeBranchCoverageGaps;
    /**
     * Analyze function coverage gaps
     */
    private analyzeFunctionCoverageGaps;
    /**
     * Detect integration test gaps
     */
    private detectIntegrationGaps;
    /**
     * Prioritize files for coverage improvement
     */
    private prioritizeFilesForImprovement;
    /**
     * Identify test generation targets
     */
    private identifyTestGenerationTargets;
    /**
     * Assign agents for coverage improvement
     */
    private assignAgentsForCoverage;
    /**
     * Calculate priority score for a file
     */
    private calculatePriorityScore;
    /**
     * Convert score to priority
     */
    private scoreToPriority;
    /**
     * Convert coverage percentage to severity
     */
    private coverageToSeverity;
    /**
     * Convert coverage percentage to priority
     */
    private coverageToPriority;
    /**
     * Get contiguous line ranges
     */
    private getLineRanges;
    /**
     * Estimate coverage gain from testing a function
     */
    private estimateCoverageGain;
    /**
     * Estimate line coverage gain from testing a range
     */
    private estimateLineCoverageGain;
    /**
     * Generate reason for test generation target
     */
    private generateTargetReason;
    /**
     * Compute cache key
     */
    private computeCacheKey;
}
/**
 * Create coverage router with optional RuVector integration
 */
export declare function createCoverageRouter(config: RuVectorConfig, thresholds?: Partial<CoverageThresholds>): CoverageRouter;
//# sourceMappingURL=coverage-router.d.ts.map