/**
 * Output types that define the standardized format for all lenses
 */
/**
 * Severity levels for issues
 */
export type Severity = 'error' | 'warning' | 'info' | 'hint';
/**
 * A single issue found by a quality tool
 */
export interface Issue {
    /** Relative file path */
    file: string;
    /** Line number (1-based) */
    line: number;
    /** Column number (1-based) */
    column?: number;
    /** End line for multi-line issues */
    endLine?: number;
    /** End column for multi-line issues */
    endColumn?: number;
    /** Issue severity */
    severity: Severity;
    /** Issue message */
    message: string;
    /** Rule or error code */
    rule?: string;
    /** Tool that found this issue */
    source: string;
    /** Category of issue (e.g., "style", "type-error", "test-failure") */
    category?: string;
    /** Suggested fix if available */
    fix?: {
        text: string;
        range?: {
            start: {
                line: number;
                column: number;
            };
            end: {
                line: number;
                column: number;
            };
        };
    };
    /** Additional context or metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Test result from test runners
 */
export interface TestResult {
    /** Test suite name */
    suite: string;
    /** Test name */
    name: string;
    /** Test status */
    status: 'passed' | 'failed' | 'skipped' | 'pending';
    /** Test duration in milliseconds */
    duration?: number;
    /** Failure message if failed */
    error?: string;
    /** File containing the test */
    file?: string;
    /** Line number of the test */
    line?: number;
}
/**
 * Code coverage information
 */
export interface Coverage {
    /** Overall line coverage percentage */
    line: number;
    /** Overall branch coverage percentage */
    branch?: number;
    /** Overall function coverage percentage */
    function?: number;
    /** Overall statement coverage percentage */
    statement?: number;
    /** Per-file coverage details */
    files?: Array<{
        file: string;
        lines: number;
        branches?: number;
        functions?: number;
        statements?: number;
        uncoveredLines?: number[];
    }>;
}
/**
 * Metrics about the analysis
 */
export interface Metrics {
    /** Total files analyzed */
    filesAnalyzed: number;
    /** Total issues found */
    totalIssues: number;
    /** Issues by severity */
    issuesBySeverity: {
        error: number;
        warning: number;
        info: number;
        hint: number;
    };
    /** Execution time in milliseconds */
    executionTime: number;
    /** Tool-specific metrics */
    custom?: Record<string, unknown>;
}
/**
 * Git-specific information
 */
export interface GitInfo {
    /** Modified files */
    modifiedFiles: string[];
    /** Untracked files */
    untrackedFiles: string[];
    /** Deleted files */
    deletedFiles: string[];
    /** Current branch */
    branch?: string;
    /** Latest commit hash */
    commit?: string;
    /** Whether working directory is clean */
    isClean: boolean;
}
/**
 * File analyzed by a lens
 */
export interface AnalyzedFile {
    /** Relative file path */
    path: string;
    /** Whether the file has issues */
    hasIssues: boolean;
}
/**
 * Per-file quality metrics aggregated from issues
 * Used for visualizations like Code City where each file needs a score
 */
export interface FileMetric {
    /** Relative file path */
    file: string;
    /** Quality score for this file (0-100, 100 = no issues) */
    score: number;
    /** Total number of issues in this file */
    issueCount: number;
    /** Number of error-severity issues */
    errorCount: number;
    /** Number of warning-severity issues */
    warningCount: number;
    /** Number of info-severity issues */
    infoCount: number;
    /** Number of hint-severity issues */
    hintCount: number;
    /** Number of auto-fixable issues (ESLint, Prettier) */
    fixableCount?: number;
    /** Issue counts by category (lens-specific) */
    categories?: Record<string, number>;
}
/**
 * Standardized result from a lens
 */
export interface LensResult {
    /** Name of the lens that generated this result */
    lensName: string;
    /** Tool that was executed */
    tool: string;
    /** Timestamp of execution */
    timestamp: number;
    /** Whether execution succeeded */
    success: boolean;
    /** Issues found */
    issues: Issue[];
    /** All files that were analyzed */
    analyzedFiles?: AnalyzedFile[];
    /** Test results if applicable */
    tests?: TestResult[];
    /** Coverage information if applicable */
    coverage?: Coverage;
    /** Per-file quality metrics aggregated from issues */
    fileMetrics?: FileMetric[];
    /** Git information if applicable */
    git?: GitInfo;
    /** Metrics about the analysis */
    metrics?: Metrics;
    /**
     * Quality score (0-100) calculated from metrics
     * 100 = perfect quality (no issues)
     * 0 = critical issues or tool failure
     *
     * Takes into account:
     * - Issue severity (errors weighted more than warnings)
     * - Issue density (issues per file analyzed)
     * - Tool-specific quality thresholds
     */
    qualityScore?: number;
    /** Raw output for debugging */
    raw?: {
        stdout: string;
        stderr: string;
        exitCode: number;
    };
    /** Error if execution failed */
    error?: {
        message: string;
        code?: string;
        stack?: string;
    };
}
/**
 * Combined quality report from multiple lenses
 */
export interface QualityReport {
    /** Project root path */
    projectPath: string;
    /** Timestamp of report generation */
    timestamp: number;
    /** Individual lens results */
    results: LensResult[];
    /** Combined issues from all lenses */
    allIssues: Issue[];
    /** Summary statistics */
    summary: {
        totalIssues: number;
        issuesBySeverity: Record<Severity, number>;
        issuesBySource: Record<string, number>;
        filesWithIssues: number;
        executionTime: number;
    };
    /** Whether all lenses succeeded */
    success: boolean;
}
/**
 * Quality Hexagon metrics - 6 dimensions of code quality (0-100 scale each)
 *
 * Used for visualization in radar/hexagon charts showing overall codebase health.
 * Each dimension maps to specific quality lenses:
 * - tests: jest, test runners
 * - deadCode: knip, unused code detection
 * - formatting: prettier, code formatters
 * - linting: eslint, static analysis
 * - types: typescript, type checking
 * - documentation: alexandria, doc coverage
 */
export interface QualityHexagonMetrics {
    /** Test coverage and passing rate (0-100) */
    tests: number;
    /** Dead code elimination score (0-100, 100 = no dead code) */
    deadCode: number;
    /** Code formatting consistency (0-100) */
    formatting: number;
    /** Linting compliance score (0-100) */
    linting: number;
    /** Type safety score (0-100) */
    types: number;
    /** Documentation coverage (0-100) */
    documentation: number;
}
/**
 * Git metadata captured during CI/CD execution
 */
export interface GitMetadata {
    /** Commit SHA */
    commit?: string;
    /** Branch name */
    branch?: string;
    /** Repository in owner/repo format */
    repository?: string;
}
/**
 * Formatted results structure for JSON output and artifact storage
 *
 * This is the standard format produced by quality-lens-cli and stored
 * as GitHub Actions artifacts. Used for retrieval and visualization.
 */
export interface FormattedResults {
    /** Execution metadata */
    metadata: {
        /** ISO timestamp of execution */
        timestamp: string;
        /** Schema version */
        version: string;
        /** Number of packages analyzed */
        totalPackages: number;
        /** Number of lenses executed */
        totalLenses: number;
        /** Git context if available */
        git?: GitMetadata;
    };
    /** Per-lens execution results */
    results: Array<{
        /** Package information */
        package: {
            name: string;
            path?: string;
        };
        /** Lens information */
        lens: {
            id: string;
            command: string;
        };
        /** Execution details */
        execution: {
            success: boolean;
            exitCode?: number;
            duration?: number;
            timestamp: number;
        };
        /** Issues found by this lens */
        issues: Issue[];
        /** Metrics from this lens */
        metrics: Record<string, unknown>;
        /** Coverage data from this lens (test runners only) */
        coverage?: Coverage;
        /** Per-file quality metrics aggregated from issues */
        fileMetrics?: FileMetric[];
        /** Quality context for scoring */
        qualityContext: Record<string, unknown>;
        /** Error message if execution failed */
        error?: string;
    }>;
    /** Aggregated quality metrics */
    qualityMetrics?: {
        /** Quality hexagon scores */
        hexagon: QualityHexagonMetrics;
    };
}
//# sourceMappingURL=output.d.ts.map