/**
 * Jest lens for test running and coverage
 */
import { BaseLens } from '../base/BaseLens.js';
import { LensResult, ExecuteResult, UnknownJson, UnknownMetadata } from '../../types/index.js';
/**
 * Type aliases for Jest coverage data structures
 */
type CoverageMapData = UnknownMetadata;
type StatementMap = UnknownMetadata;
type FunctionMap = UnknownMetadata;
type BranchMap = UnknownMetadata;
type FailureDetail = UnknownJson;
type OpenHandle = UnknownJson;
type UncheckedKey = UnknownJson;
/**
 * Jest test status
 */
type TestStatus = 'passed' | 'failed' | 'skipped' | 'pending' | 'todo' | 'disabled';
/**
 * Jest assertion result
 */
interface AssertionResult {
    ancestorTitles: string[];
    failureDetails: FailureDetail[];
    failureMessages: string[];
    fullName: string;
    location?: {
        column: number;
        line: number;
    };
    numPassingAsserts: number;
    status: TestStatus;
    title: string;
    duration?: number;
}
/**
 * Jest test result for a single test file
 */
interface TestResult {
    assertionResults: AssertionResult[];
    endTime: number;
    message: string;
    name: string;
    startTime: number;
    status: 'passed' | 'failed';
    summary: string;
    failureMessage?: string;
    testFilePath: string;
    perfStats: {
        end: number;
        runtime: number;
        slow: boolean;
        start: number;
    };
    coverage?: {
        [key: string]: {
            path: string;
            statementMap: StatementMap;
            fnMap: FunctionMap;
            branchMap: BranchMap;
            s: {
                [key: string]: number;
            };
            f: {
                [key: string]: number;
            };
            b: {
                [key: string]: number[];
            };
        };
    };
}
/**
 * Jest aggregated results
 */
interface AggregatedResults {
    numFailedTestSuites: number;
    numFailedTests: number;
    numPassedTestSuites: number;
    numPassedTests: number;
    numPendingTestSuites: number;
    numPendingTests: number;
    numRuntimeErrorTestSuites: number;
    numTodoTests: number;
    numTotalTestSuites: number;
    numTotalTests: number;
    openHandles: OpenHandle[];
    snapshot: {
        added: number;
        didUpdate: boolean;
        failure: boolean;
        filesAdded: number;
        filesRemoved: number;
        filesRemovedList: string[];
        filesUnmatched: number;
        filesUpdated: number;
        matched: number;
        total: number;
        unchecked: number;
        uncheckedKeysByFile: UncheckedKey[];
        unmatched: number;
        updated: number;
    };
    startTime: number;
    success: boolean;
    testResults: TestResult[];
    wasInterrupted: boolean;
    coverageMap?: CoverageMapData;
}
/**
 * Lens for Jest test runner and coverage
 */
export declare class JestLens extends BaseLens<AggregatedResults> {
    readonly name = "jest";
    readonly description = "JavaScript test runner and coverage";
    readonly languages: string[];
    readonly supportedTools: string[];
    readonly requirements: import("../..").LensRequirements;
    private pathMapper?;
    /**
     * Calculate quality score (0-100) from Jest results
     *
     * Scoring algorithm:
     * - Base score from test pass rate: (passedTests / totalTests) × 100
     * - Penalty for skipped tests: -0.5 per skipped test
     * - Bonus for high coverage: +10 if coverage > 80%, +5 if > 60%
     * - Floor at 0, cap at 100
     *
     * Examples:
     * - All tests pass, no skips = 100
     * - 90% pass rate = 90
     * - 90% pass rate + 80% coverage = 100
     * - 100% pass rate + 20 skipped tests = 90
     */
    static calculateQualityScore(result: LensResult): number;
    /**
     * Parse Jest JSON output
     */
    parse(output: ExecuteResult): AggregatedResults;
    /**
     * Format Jest results to standard format
     */
    format(parsed: AggregatedResults): LensResult;
    /**
     * Build structured coverage data from Jest coverage map
     */
    private buildCoverageData;
    /**
     * Extract uncovered line numbers from statement map
     */
    private getUncoveredLines;
    /**
     * Process coverage data and generate issues for uncovered code
     */
    private processCoverageData;
    /**
     * Extract clean error message from Jest failure message
     */
    private extractErrorMessage;
    /**
     * Format test failure message
     */
    private formatTestFailureMessage;
    /**
     * Get empty results structure
     */
    private getEmptyResults;
    /**
     * Normalize results to ensure all expected fields exist
     */
    private normalizeResults;
    /**
     * Get or create path mapper
     */
    private getPathMapper;
    /**
     * Override execute to ensure JSON format and coverage
     */
    execute(): Promise<ExecuteResult>;
}
export {};
//# sourceMappingURL=JestLens.d.ts.map