/**
 * Agentic QE v3 - RuVector Fallback Logic
 *
 * Rule-based fallback implementations when RuVector is unavailable.
 * All QE features MUST work without RuVector - this provides the baseline.
 */
import type { TestTask, AgentRoutingResult, FileComplexityResult, RiskClassification, DiffContext, FileChange, CoverageRoutingResult, FileCoverage, CoverageGap, GraphBoundariesResult, BoundaryCrossing, QLearningRouter, ASTComplexityAnalyzer, DiffRiskClassifier, CoverageRouter, GraphBoundariesAnalyzer, QLearningState, QLearningAction } from './interfaces';
import type { Severity, Priority } from '../../shared/types';
/**
 * Rule-based fallback for Q-Learning router
 * Uses simple heuristics instead of ML-based routing
 */
export declare class FallbackQLearningRouter implements QLearningRouter {
    private feedback;
    routeTask(task: TestTask): Promise<AgentRoutingResult>;
    routeTasks(tasks: TestTask[]): Promise<AgentRoutingResult[]>;
    provideFeedback(taskId: string, result: {
        success: boolean;
        durationMs: number;
        quality: number;
    }): Promise<void>;
    getQValue(_state: QLearningState, _action: QLearningAction): number;
    reset(): Promise<void>;
    exportModel(): Promise<Record<string, unknown>>;
    importModel(_model: Record<string, unknown>): Promise<void>;
    private computeRuleBasedRouting;
    private mapTaskToAgent;
    private getAlternatives;
}
/**
 * Rule-based fallback for AST complexity analysis
 * Uses simple heuristics based on file size and patterns
 */
export declare class FallbackASTComplexityAnalyzer implements ASTComplexityAnalyzer {
    analyzeFile(filePath: string): Promise<FileComplexityResult>;
    analyzeFiles(filePaths: string[]): Promise<FileComplexityResult[]>;
    getComplexityRanking(filePaths: string[]): Promise<Array<{
        filePath: string;
        score: number;
        priority: Priority;
    }>>;
    suggestTestFocus(filePaths: string[]): Promise<Array<{
        filePath: string;
        functions: string[];
        reason: string;
    }>>;
    private estimateComplexity;
    private calculateOverallScore;
    private scoreToRiskLevel;
    private scoreToPriority;
    private generateRecommendations;
}
/**
 * Rule-based fallback for diff risk classification
 */
export declare class FallbackDiffRiskClassifier implements DiffRiskClassifier {
    private readonly HIGH_RISK_PATTERNS;
    private readonly SENSITIVE_FILE_PATTERNS;
    classifyDiff(context: DiffContext): Promise<RiskClassification>;
    rankFilesByRisk(files: FileChange[]): Promise<Array<{
        filePath: string;
        riskScore: number;
        riskLevel: Severity;
    }>>;
    requiresSecurityReview(context: DiffContext): Promise<boolean>;
    getRecommendedReviewers(_context: DiffContext): Promise<string[]>;
    predictDefects(context: DiffContext): Promise<Array<{
        filePath: string;
        probability: number;
        type: string;
        location?: {
            line: number;
            column: number;
        };
    }>>;
    private calculateRiskScore;
    private calculateFileRisk;
    private scoreToLevel;
    private identifyHighRiskFiles;
    private getRecommendedTests;
}
/**
 * Rule-based fallback for coverage routing
 */
export declare class FallbackCoverageRouter implements CoverageRouter {
    private readonly DEFAULT_TARGET_COVERAGE;
    analyzeCoverage(coverageData: FileCoverage[], targetCoverage?: number): Promise<CoverageRoutingResult>;
    getCoverageGaps(coverageData: FileCoverage[]): Promise<CoverageGap[]>;
    prioritizeForCoverage(files: string[], coverageData: FileCoverage[]): Promise<string[]>;
    suggestTestsForCoverage(filePath: string, coverage: FileCoverage): Promise<Array<{
        testType: string;
        target: string;
        expectedCoverageGain: number;
    }>>;
    private prioritizeFiles;
    private getTestGenerationTargets;
    private assignAgents;
    private gapSeverity;
    private coverageToPriority;
}
/**
 * Rule-based fallback for graph boundaries analysis
 */
export declare class FallbackGraphBoundariesAnalyzer implements GraphBoundariesAnalyzer {
    analyzeBoundaries(entryPoints: string[]): Promise<GraphBoundariesResult>;
    getBoundaryCrossings(modules: string[]): Promise<BoundaryCrossing[]>;
    getCriticalPaths(): Promise<Array<{
        path: string[];
        importance: number;
        reason: string;
    }>>;
    suggestIntegrationTests(): Promise<Array<{
        location: string;
        modules: string[];
        priority: Priority;
        reason: string;
    }>>;
    detectViolations(): Promise<Array<{
        type: string;
        location: string;
        severity: Severity;
        suggestion: string;
    }>>;
    private inferModules;
    private inferBoundaries;
    private suggestTests;
}
/**
 * Create fallback implementations for all RuVector components
 */
export declare function createFallbackComponents(): {
    qLearningRouter: QLearningRouter;
    astComplexityAnalyzer: ASTComplexityAnalyzer;
    diffRiskClassifier: DiffRiskClassifier;
    coverageRouter: CoverageRouter;
    graphBoundariesAnalyzer: GraphBoundariesAnalyzer;
};
//# sourceMappingURL=fallback.d.ts.map