import { z } from 'zod';
export declare const TestTypeSchema: z.ZodEnum<["unit", "integration", "e2e", "regression", "smoke", "performance", "security", "manual"]>;
export type TestType = z.infer<typeof TestTypeSchema>;
export declare const PrioritySchema: z.ZodEnum<["critical", "high", "medium", "low"]>;
export type Priority = z.infer<typeof PrioritySchema>;
export declare const SeveritySchema: z.ZodEnum<["critical", "high", "medium", "low"]>;
export type Severity = z.infer<typeof SeveritySchema>;
export declare const RiskLevelSchema: z.ZodEnum<["critical", "high", "medium", "low", "minimal"]>;
export type RiskLevel = z.infer<typeof RiskLevelSchema>;
export declare const TestCaseSchema: z.ZodObject<{
    id: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
    type: z.ZodEnum<["unit", "integration", "e2e", "regression", "smoke", "performance", "security", "manual"]>;
    targetFiles: z.ZodArray<z.ZodString, "many">;
    steps: z.ZodArray<z.ZodString, "many">;
    assertions: z.ZodArray<z.ZodString, "many">;
    unknowns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    type: "unit" | "integration" | "e2e" | "regression" | "smoke" | "performance" | "security" | "manual";
    id: string;
    title: string;
    description: string;
    priority: "critical" | "high" | "medium" | "low";
    targetFiles: string[];
    steps: string[];
    assertions: string[];
    unknowns?: string[] | undefined;
}, {
    type: "unit" | "integration" | "e2e" | "regression" | "smoke" | "performance" | "security" | "manual";
    id: string;
    title: string;
    description: string;
    priority: "critical" | "high" | "medium" | "low";
    targetFiles: string[];
    steps: string[];
    assertions: string[];
    unknowns?: string[] | undefined;
}>;
export type TestCase = z.infer<typeof TestCaseSchema>;
export declare const RiskItemSchema: z.ZodObject<{
    id: z.ZodString;
    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
    description: z.ZodString;
    mitigation: z.ZodString;
    affectedFiles: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    id: string;
    description: string;
    severity: "critical" | "high" | "medium" | "low";
    mitigation: string;
    affectedFiles: string[];
}, {
    id: string;
    description: string;
    severity: "critical" | "high" | "medium" | "low";
    mitigation: string;
    affectedFiles: string[];
}>;
export type RiskItem = z.infer<typeof RiskItemSchema>;
export declare const FileCoverageSchema: z.ZodObject<{
    path: z.ZodString;
    testCoverage: z.ZodEnum<["full", "partial", "none", "unknown"]>;
    gaps: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    path: string;
    testCoverage: "unknown" | "full" | "partial" | "none";
    gaps: string[];
}, {
    path: string;
    testCoverage: "unknown" | "full" | "partial" | "none";
    gaps: string[];
}>;
export type FileCoverage = z.infer<typeof FileCoverageSchema>;
export declare const CoverageSummarySchema: z.ZodObject<{
    files: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        testCoverage: z.ZodEnum<["full", "partial", "none", "unknown"]>;
        gaps: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        path: string;
        testCoverage: "unknown" | "full" | "partial" | "none";
        gaps: string[];
    }, {
        path: string;
        testCoverage: "unknown" | "full" | "partial" | "none";
        gaps: string[];
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    files: {
        path: string;
        testCoverage: "unknown" | "full" | "partial" | "none";
        gaps: string[];
    }[];
}, {
    files: {
        path: string;
        testCoverage: "unknown" | "full" | "partial" | "none";
        gaps: string[];
    }[];
}>;
export type CoverageSummary = z.infer<typeof CoverageSummarySchema>;
export declare const SummarySchema: z.ZodObject<{
    filesAnalyzed: z.ZodNumber;
    testsRecommended: z.ZodNumber;
    riskLevel: z.ZodEnum<["critical", "high", "medium", "low", "minimal"]>;
}, "strip", z.ZodTypeAny, {
    filesAnalyzed: number;
    testsRecommended: number;
    riskLevel: "critical" | "high" | "medium" | "low" | "minimal";
}, {
    filesAnalyzed: number;
    testsRecommended: number;
    riskLevel: "critical" | "high" | "medium" | "low" | "minimal";
}>;
export type Summary = z.infer<typeof SummarySchema>;
export declare const CoverageVerdictSchema: z.ZodOptional<z.ZodObject<{
    verdict: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
    recommendations_total: z.ZodNumber;
    already_covered: z.ZodNumber;
    partially_covered: z.ZodNumber;
    missing: z.ZodNumber;
    critical_missing: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    verdict: "PASS" | "WARN" | "FAIL";
    recommendations_total: number;
    already_covered: number;
    partially_covered: number;
    missing: number;
    critical_missing: number;
}, {
    verdict: "PASS" | "WARN" | "FAIL";
    recommendations_total: number;
    already_covered: number;
    partially_covered: number;
    missing: number;
    critical_missing: number;
}>>;
export type CoverageVerdict = z.infer<typeof CoverageVerdictSchema>;
export declare const BaselineComparisonSchema: z.ZodOptional<z.ZodObject<{
    previousTests: z.ZodNumber;
    currentTests: z.ZodNumber;
    previousCovered: z.ZodNumber;
    currentCovered: z.ZodNumber;
    previousRiskLevel: z.ZodString;
    currentRiskLevel: z.ZodString;
    improved: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    previousTests: number;
    currentTests: number;
    previousCovered: number;
    currentCovered: number;
    previousRiskLevel: string;
    currentRiskLevel: string;
    improved: boolean;
}, {
    previousTests: number;
    currentTests: number;
    previousCovered: number;
    currentCovered: number;
    previousRiskLevel: string;
    currentRiskLevel: string;
    improved: boolean;
}>>;
export type BaselineComparison = z.infer<typeof BaselineComparisonSchema>;
export declare const MetadataSchema: z.ZodObject<{
    provider: z.ZodString;
    model: z.ZodString;
    contextTruncated: z.ZodBoolean;
    truncatedFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    unknownsCount: z.ZodNumber;
    analyzedAt: z.ZodString;
    diffSource: z.ZodOptional<z.ZodString>;
    coverageVerdict: z.ZodOptional<z.ZodObject<{
        verdict: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
        recommendations_total: z.ZodNumber;
        already_covered: z.ZodNumber;
        partially_covered: z.ZodNumber;
        missing: z.ZodNumber;
        critical_missing: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        verdict: "PASS" | "WARN" | "FAIL";
        recommendations_total: number;
        already_covered: number;
        partially_covered: number;
        missing: number;
        critical_missing: number;
    }, {
        verdict: "PASS" | "WARN" | "FAIL";
        recommendations_total: number;
        already_covered: number;
        partially_covered: number;
        missing: number;
        critical_missing: number;
    }>>;
    baselineComparison: z.ZodOptional<z.ZodObject<{
        previousTests: z.ZodNumber;
        currentTests: z.ZodNumber;
        previousCovered: z.ZodNumber;
        currentCovered: z.ZodNumber;
        previousRiskLevel: z.ZodString;
        currentRiskLevel: z.ZodString;
        improved: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        previousTests: number;
        currentTests: number;
        previousCovered: number;
        currentCovered: number;
        previousRiskLevel: string;
        currentRiskLevel: string;
        improved: boolean;
    }, {
        previousTests: number;
        currentTests: number;
        previousCovered: number;
        currentCovered: number;
        previousRiskLevel: string;
        currentRiskLevel: string;
        improved: boolean;
    }>>;
    /** Indicates if the result was loaded from cache */
    cached: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    model: string;
    provider: string;
    contextTruncated: boolean;
    unknownsCount: number;
    analyzedAt: string;
    truncatedFiles?: string[] | undefined;
    diffSource?: string | undefined;
    coverageVerdict?: {
        verdict: "PASS" | "WARN" | "FAIL";
        recommendations_total: number;
        already_covered: number;
        partially_covered: number;
        missing: number;
        critical_missing: number;
    } | undefined;
    baselineComparison?: {
        previousTests: number;
        currentTests: number;
        previousCovered: number;
        currentCovered: number;
        previousRiskLevel: string;
        currentRiskLevel: string;
        improved: boolean;
    } | undefined;
    cached?: boolean | undefined;
}, {
    model: string;
    provider: string;
    contextTruncated: boolean;
    unknownsCount: number;
    analyzedAt: string;
    truncatedFiles?: string[] | undefined;
    diffSource?: string | undefined;
    coverageVerdict?: {
        verdict: "PASS" | "WARN" | "FAIL";
        recommendations_total: number;
        already_covered: number;
        partially_covered: number;
        missing: number;
        critical_missing: number;
    } | undefined;
    baselineComparison?: {
        previousTests: number;
        currentTests: number;
        previousCovered: number;
        currentCovered: number;
        previousRiskLevel: string;
        currentRiskLevel: string;
        improved: boolean;
    } | undefined;
    cached?: boolean | undefined;
}>;
export type Metadata = z.infer<typeof MetadataSchema>;
export declare const ReportSchema: z.ZodObject<{
    version: z.ZodString;
    generatedAt: z.ZodString;
    summary: z.ZodObject<{
        filesAnalyzed: z.ZodNumber;
        testsRecommended: z.ZodNumber;
        riskLevel: z.ZodEnum<["critical", "high", "medium", "low", "minimal"]>;
    }, "strip", z.ZodTypeAny, {
        filesAnalyzed: number;
        testsRecommended: number;
        riskLevel: "critical" | "high" | "medium" | "low" | "minimal";
    }, {
        filesAnalyzed: number;
        testsRecommended: number;
        riskLevel: "critical" | "high" | "medium" | "low" | "minimal";
    }>;
    testCases: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        title: z.ZodString;
        description: z.ZodString;
        priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
        type: z.ZodEnum<["unit", "integration", "e2e", "regression", "smoke", "performance", "security", "manual"]>;
        targetFiles: z.ZodArray<z.ZodString, "many">;
        steps: z.ZodArray<z.ZodString, "many">;
        assertions: z.ZodArray<z.ZodString, "many">;
        unknowns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        type: "unit" | "integration" | "e2e" | "regression" | "smoke" | "performance" | "security" | "manual";
        id: string;
        title: string;
        description: string;
        priority: "critical" | "high" | "medium" | "low";
        targetFiles: string[];
        steps: string[];
        assertions: string[];
        unknowns?: string[] | undefined;
    }, {
        type: "unit" | "integration" | "e2e" | "regression" | "smoke" | "performance" | "security" | "manual";
        id: string;
        title: string;
        description: string;
        priority: "critical" | "high" | "medium" | "low";
        targetFiles: string[];
        steps: string[];
        assertions: string[];
        unknowns?: string[] | undefined;
    }>, "many">;
    risks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
        description: z.ZodString;
        mitigation: z.ZodString;
        affectedFiles: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        id: string;
        description: string;
        severity: "critical" | "high" | "medium" | "low";
        mitigation: string;
        affectedFiles: string[];
    }, {
        id: string;
        description: string;
        severity: "critical" | "high" | "medium" | "low";
        mitigation: string;
        affectedFiles: string[];
    }>, "many">;
    coverage: z.ZodObject<{
        files: z.ZodArray<z.ZodObject<{
            path: z.ZodString;
            testCoverage: z.ZodEnum<["full", "partial", "none", "unknown"]>;
            gaps: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            path: string;
            testCoverage: "unknown" | "full" | "partial" | "none";
            gaps: string[];
        }, {
            path: string;
            testCoverage: "unknown" | "full" | "partial" | "none";
            gaps: string[];
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        files: {
            path: string;
            testCoverage: "unknown" | "full" | "partial" | "none";
            gaps: string[];
        }[];
    }, {
        files: {
            path: string;
            testCoverage: "unknown" | "full" | "partial" | "none";
            gaps: string[];
        }[];
    }>;
    metadata: z.ZodObject<{
        provider: z.ZodString;
        model: z.ZodString;
        contextTruncated: z.ZodBoolean;
        truncatedFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        unknownsCount: z.ZodNumber;
        analyzedAt: z.ZodString;
        diffSource: z.ZodOptional<z.ZodString>;
        coverageVerdict: z.ZodOptional<z.ZodObject<{
            verdict: z.ZodEnum<["PASS", "WARN", "FAIL"]>;
            recommendations_total: z.ZodNumber;
            already_covered: z.ZodNumber;
            partially_covered: z.ZodNumber;
            missing: z.ZodNumber;
            critical_missing: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            verdict: "PASS" | "WARN" | "FAIL";
            recommendations_total: number;
            already_covered: number;
            partially_covered: number;
            missing: number;
            critical_missing: number;
        }, {
            verdict: "PASS" | "WARN" | "FAIL";
            recommendations_total: number;
            already_covered: number;
            partially_covered: number;
            missing: number;
            critical_missing: number;
        }>>;
        baselineComparison: z.ZodOptional<z.ZodObject<{
            previousTests: z.ZodNumber;
            currentTests: z.ZodNumber;
            previousCovered: z.ZodNumber;
            currentCovered: z.ZodNumber;
            previousRiskLevel: z.ZodString;
            currentRiskLevel: z.ZodString;
            improved: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            previousTests: number;
            currentTests: number;
            previousCovered: number;
            currentCovered: number;
            previousRiskLevel: string;
            currentRiskLevel: string;
            improved: boolean;
        }, {
            previousTests: number;
            currentTests: number;
            previousCovered: number;
            currentCovered: number;
            previousRiskLevel: string;
            currentRiskLevel: string;
            improved: boolean;
        }>>;
        /** Indicates if the result was loaded from cache */
        cached: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        model: string;
        provider: string;
        contextTruncated: boolean;
        unknownsCount: number;
        analyzedAt: string;
        truncatedFiles?: string[] | undefined;
        diffSource?: string | undefined;
        coverageVerdict?: {
            verdict: "PASS" | "WARN" | "FAIL";
            recommendations_total: number;
            already_covered: number;
            partially_covered: number;
            missing: number;
            critical_missing: number;
        } | undefined;
        baselineComparison?: {
            previousTests: number;
            currentTests: number;
            previousCovered: number;
            currentCovered: number;
            previousRiskLevel: string;
            currentRiskLevel: string;
            improved: boolean;
        } | undefined;
        cached?: boolean | undefined;
    }, {
        model: string;
        provider: string;
        contextTruncated: boolean;
        unknownsCount: number;
        analyzedAt: string;
        truncatedFiles?: string[] | undefined;
        diffSource?: string | undefined;
        coverageVerdict?: {
            verdict: "PASS" | "WARN" | "FAIL";
            recommendations_total: number;
            already_covered: number;
            partially_covered: number;
            missing: number;
            critical_missing: number;
        } | undefined;
        baselineComparison?: {
            previousTests: number;
            currentTests: number;
            previousCovered: number;
            currentCovered: number;
            previousRiskLevel: string;
            currentRiskLevel: string;
            improved: boolean;
        } | undefined;
        cached?: boolean | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    version: string;
    generatedAt: string;
    summary: {
        filesAnalyzed: number;
        testsRecommended: number;
        riskLevel: "critical" | "high" | "medium" | "low" | "minimal";
    };
    testCases: {
        type: "unit" | "integration" | "e2e" | "regression" | "smoke" | "performance" | "security" | "manual";
        id: string;
        title: string;
        description: string;
        priority: "critical" | "high" | "medium" | "low";
        targetFiles: string[];
        steps: string[];
        assertions: string[];
        unknowns?: string[] | undefined;
    }[];
    risks: {
        id: string;
        description: string;
        severity: "critical" | "high" | "medium" | "low";
        mitigation: string;
        affectedFiles: string[];
    }[];
    coverage: {
        files: {
            path: string;
            testCoverage: "unknown" | "full" | "partial" | "none";
            gaps: string[];
        }[];
    };
    metadata: {
        model: string;
        provider: string;
        contextTruncated: boolean;
        unknownsCount: number;
        analyzedAt: string;
        truncatedFiles?: string[] | undefined;
        diffSource?: string | undefined;
        coverageVerdict?: {
            verdict: "PASS" | "WARN" | "FAIL";
            recommendations_total: number;
            already_covered: number;
            partially_covered: number;
            missing: number;
            critical_missing: number;
        } | undefined;
        baselineComparison?: {
            previousTests: number;
            currentTests: number;
            previousCovered: number;
            currentCovered: number;
            previousRiskLevel: string;
            currentRiskLevel: string;
            improved: boolean;
        } | undefined;
        cached?: boolean | undefined;
    };
}, {
    version: string;
    generatedAt: string;
    summary: {
        filesAnalyzed: number;
        testsRecommended: number;
        riskLevel: "critical" | "high" | "medium" | "low" | "minimal";
    };
    testCases: {
        type: "unit" | "integration" | "e2e" | "regression" | "smoke" | "performance" | "security" | "manual";
        id: string;
        title: string;
        description: string;
        priority: "critical" | "high" | "medium" | "low";
        targetFiles: string[];
        steps: string[];
        assertions: string[];
        unknowns?: string[] | undefined;
    }[];
    risks: {
        id: string;
        description: string;
        severity: "critical" | "high" | "medium" | "low";
        mitigation: string;
        affectedFiles: string[];
    }[];
    coverage: {
        files: {
            path: string;
            testCoverage: "unknown" | "full" | "partial" | "none";
            gaps: string[];
        }[];
    };
    metadata: {
        model: string;
        provider: string;
        contextTruncated: boolean;
        unknownsCount: number;
        analyzedAt: string;
        truncatedFiles?: string[] | undefined;
        diffSource?: string | undefined;
        coverageVerdict?: {
            verdict: "PASS" | "WARN" | "FAIL";
            recommendations_total: number;
            already_covered: number;
            partially_covered: number;
            missing: number;
            critical_missing: number;
        } | undefined;
        baselineComparison?: {
            previousTests: number;
            currentTests: number;
            previousCovered: number;
            currentCovered: number;
            previousRiskLevel: string;
            currentRiskLevel: string;
            improved: boolean;
        } | undefined;
        cached?: boolean | undefined;
    };
}>;
export type Report = z.infer<typeof ReportSchema>;
export declare function validateReport(data: unknown): Report;
export declare function createEmptyReport(metadata?: Partial<Metadata>): Report;
//# sourceMappingURL=report.d.ts.map