/**
 * Traceability Checker - Maintain 100% bidirectional traceability
 * from requirements → code → tests → deployment
 *
 * Features:
 * - Bidirectional tracing (requirements ↔ code ↔ tests)
 * - Orphan detection (requirements without code, code without requirements)
 * - Coverage analysis (percentage of requirements traced)
 * - Gap identification (missing code, tests, documentation)
 * - Matrix generation (CSV, Excel, Markdown, HTML)
 * - Construction gate validation (100% P0 requirements traced)
 *
 * Performance targets:
 * - NFR-TRACE-001: ID extraction <1min for 1000 files
 * - NFR-TRACE-05: Matrix generation <30s for 1000 requirements
 */
import { TraceabilityMatrix } from './matrix-generator.js';
export interface Requirement {
    id: string;
    type: 'use-case' | 'nfr' | 'user-story' | 'feature' | 'acceptance-criteria';
    title: string;
    priority?: 'P0' | 'P1' | 'P2';
    filePath: string;
}
export interface CodeReference {
    filePath: string;
    requirementIds: string[];
    lineNumbers: number[];
}
export interface TestReference {
    filePath: string;
    requirementIds: string[];
    testNames: string[];
}
export interface ScanResult {
    requirements: Map<string, Requirement>;
    code: Map<string, CodeReference>;
    tests: Map<string, TestReference>;
    scanTime: number;
}
export interface TraceabilityLink {
    requirementId: string;
    type: 'use-case' | 'nfr' | 'user-story' | 'feature' | 'acceptance-criteria';
    linkedItems: LinkedItem[];
    coverage: CoverageMetrics;
    lastVerified: Date;
}
export interface LinkedItem {
    type: 'code' | 'test' | 'documentation' | 'deployment';
    path: string;
    lineNumber?: number;
    verified: boolean;
    confidence: number;
}
export interface CoverageMetrics {
    hasCode: boolean;
    hasTests: boolean;
    hasDocumentation: boolean;
    hasDeployment: boolean;
    completeness: number;
}
export interface TraceabilityReport {
    totalRequirements: number;
    tracedRequirements: number;
    coveragePercentage: number;
    orphanedRequirements: string[];
    orphanedCode: string[];
    orphanedTests: string[];
    gapsByRequirement: Map<string, string[]>;
    matrix: TraceabilityMatrix;
}
export interface VerificationResult {
    verified: boolean;
    issues: string[];
    warnings: string[];
}
export interface OrphanReport {
    orphanedRequirements: string[];
    orphanedCode: string[];
    orphanedTests: string[];
    severity: Map<string, 'critical' | 'warning' | 'info'>;
}
export interface CoverageReport {
    percentage: number;
    byType: Map<string, number>;
    byPriority: Map<string, number>;
    gaps: GapAnalysis;
}
export interface GapAnalysis {
    requirementsWithoutCode: string[];
    requirementsWithoutTests: string[];
    requirementsWithoutDocumentation: string[];
    codeWithoutRequirements: string[];
    testsWithoutRequirements: string[];
}
export interface ValidationResult {
    passed: boolean;
    coverage: number;
    threshold: number;
    issues: string[];
}
export interface GateValidationResult {
    passed: boolean;
    p0Coverage: number;
    p1Coverage: number;
    issues: string[];
    warnings: string[];
}
/**
 * TraceabilityChecker - Main class for traceability analysis
 */
export declare class TraceabilityChecker {
    private projectPath;
    private idExtractor;
    private matrixGenerator;
    private requirements;
    private codeReferences;
    private testReferences;
    constructor(projectPath: string);
    /**
     * Scan requirements directory for requirement IDs
     */
    scanRequirements(requirementsPath?: string): Promise<Map<string, Requirement>>;
    /**
     * Scan code directory for requirement IDs
     */
    scanCode(codePath?: string): Promise<Map<string, CodeReference>>;
    /**
     * Scan test directory for requirement IDs
     */
    scanTests(testPath?: string): Promise<Map<string, TestReference>>;
    /**
     * Scan all directories (requirements, code, tests)
     */
    scanAll(): Promise<ScanResult>;
    /**
     * Build traceability links from scan results
     */
    buildTraceabilityLinks(): Promise<Map<string, TraceabilityLink>>;
    /**
     * Verify links integrity
     */
    verifyLinks(links: Map<string, TraceabilityLink>): Promise<VerificationResult>;
    /**
     * Detect orphaned requirements, code, and tests
     */
    detectOrphans(): Promise<OrphanReport>;
    /**
     * Calculate overall coverage
     */
    calculateCoverage(): Promise<CoverageReport>;
    /**
     * Calculate coverage by requirement type
     */
    calculateCoverageByType(type: 'use-case' | 'nfr'): Promise<Map<string, number>>;
    /**
     * Identify gaps in traceability
     */
    identifyGaps(): Promise<GapAnalysis>;
    /**
     * Generate traceability matrix
     */
    generateMatrix(): Promise<TraceabilityMatrix>;
    /**
     * Export matrix to file
     */
    exportMatrix(format: 'csv' | 'excel' | 'markdown' | 'html', outputPath?: string): Promise<string>;
    /**
     * Generate comprehensive traceability report
     */
    generateReport(): Promise<TraceabilityReport>;
    /**
     * Generate gap report (markdown format)
     */
    generateGapReport(): Promise<string>;
    /**
     * Export report to file
     */
    exportReport(format: 'markdown' | 'json' | 'html', outputPath?: string): Promise<string>;
    /**
     * Validate traceability against threshold
     */
    validateTraceability(threshold: number): Promise<ValidationResult>;
    /**
     * Check Construction gate criteria (100% P0 requirements traced)
     */
    checkConstructionGate(): Promise<GateValidationResult>;
    /**
     * Add a traceability link manually
     */
    addLink(requirementId: string, linkedItem: LinkedItem): Promise<void>;
    /**
     * Remove a traceability link
     */
    removeLink(requirementId: string, itemPath: string): Promise<void>;
    /**
     * Update a traceability link
     */
    updateLink(requirementId: string, itemPath: string, updates: Partial<LinkedItem>): Promise<void>;
    private extractTitle;
    private extractPriority;
    private extractTestNames;
    private calculateCoverageForRequirements;
}
//# sourceMappingURL=traceability-checker.d.ts.map