import { type GraphReport } from "./graph.js";
import { type ReadinessReport } from "./readiness.js";
import { type SecurityDiffSummary } from "../security-diff.js";
import type { ContextLensSummary } from "../context-lens.js";
import type { SecurityPolicyInventorySummary } from "../security-policy-inventory.js";
import { type ExecutableSurfaceDiff } from "../executable-surface-diff.js";
import { type ExecutableSurfaceInventory } from "../executable-surface-inventory.js";
import { type ConfigOverrides } from "../config.js";
import type { SkillDiscoveryCiPolicyMode } from "../types/configuration.js";
import type { SecurityCiPolicyMode } from "../types/configuration.js";
import type { ScanBoundaryCiPolicyMode } from "../types/configuration.js";
import type { ExecutableSurfaceCiPolicyMode } from "../types/configuration.js";
import type { DiagnosticsCiPolicyMode, DiagnosticsConfig, MetadataCiPolicyMode, MetadataConfig, QualityCiPolicyMode, QualityConfig, SecurityConfig } from "../types/configuration.js";
import type { SecurityPolicyAssetEvidence } from "../security-policy-inventory.js";
import { type RepositoryCollectionInstrumentation } from "../repository-evidence.js";
import { type SkillDiscoveryDiff } from "../skill-discovery-diff.js";
import type { SkillDiscoveryIndex } from "../skill-discovery.js";
import { type InspectionCoverage, type InspectionCoverageChange, type InspectionCoverageDiff } from "../inspection-coverage.js";
import { type ScanBoundaryEvidence, type EffectiveCiScanBoundaryEvidence } from "../scan-boundary.js";
import { type ScanBoundaryDiff } from "../scan-boundary-diff.js";
import { type QualityPolicyDiff } from "../quality-policy-diff.js";
import { type MetadataPolicyDiff } from "../metadata-policy-diff.js";
import { type DiagnosticSeverityPolicyDiff } from "../diagnostic-severity-policy-diff.js";
import type { SuppressedFindingEvidence } from "../types/diagnostics.js";
export type DiffFormat = "json" | "markdown";
export declare const DIFF_JSON_SCHEMA_VERSION: "renma.diff.v1";
export interface DiffReport {
    root: string;
    from: DiffEndpoint;
    to: DiffEndpoint;
    summary: {
        readinessScoreDelta: number;
        readinessLevelChanged: boolean;
        totalAssetsDelta: number;
        ownershipCoverageDelta: number;
        graphResolutionDelta: number;
        findingsDelta: number;
        highOrCriticalFindingsDelta: number;
        contentChangedAssets?: number;
    };
    catalog: {
        addedAssets: AssetDelta[];
        removedAssets: AssetDelta[];
        changedAssets: AssetChange[];
    };
    graph: {
        addedEdges: EdgeDelta[];
        removedEdges: EdgeDelta[];
        newUnresolvedEdges: EdgeDelta[];
        resolvedEdges: EdgeDelta[];
    };
    readiness: {
        checkChanges: ReadinessCheckChange[];
    };
    discovery: SkillDiscoveryDiff;
    executableSurface: ExecutableSurfaceDiff;
    security: SecurityDiffSummary;
    scanBoundary: ScanBoundaryDiff;
    qualityPolicy: QualityPolicyDiff;
    metadataPolicy?: MetadataPolicyDiff;
    diagnosticSeverityPolicy?: DiagnosticSeverityPolicyDiff;
    inspectionCoverage: InspectionCoverageDiff;
    findings: {
        added: FindingDelta[];
        removed: FindingDelta[];
        countById: Array<{
            id: string;
            from: number;
            to: number;
            delta: number;
        }>;
        suppressed: {
            from: SuppressedFindingEvidence[];
            to: SuppressedFindingEvidence[];
            added: SuppressedFindingEvidence[];
            removed: SuppressedFindingEvidence[];
        };
    };
}
export type DiffReportWithoutSkillDiscovery = Omit<DiffReport, "discovery">;
type DiffReportFormatInput = DiffReport | DiffReportWithoutSkillDiscovery;
interface DiffOwnershipEndpoint {
    ownedAssets: number;
    eligibleAssets: number;
    coveragePercent: number;
}
export interface DiffEndpoint {
    ref: string;
    scannedFileCount: number;
    totalAssets: number;
    readinessScore: number;
    readinessLevel: string;
    ownership?: DiffOwnershipEndpoint | undefined;
    contextLens?: ContextLensSummary;
    securityPolicyInventory?: SecurityPolicyInventorySummary;
}
export interface AssetDelta {
    id: string;
    path?: string | undefined;
    kind?: string | undefined;
    contentHash?: string | undefined;
    declaredOwner: string | null;
    effectiveOwner: string | null;
    status?: string | undefined;
    statusReason?: string | undefined;
    statusChangedAt?: string | undefined;
}
declare const COMPARABLE_ASSET_FIELDS: readonly ["path", "kind", "declaredOwner", "effectiveOwner", "status", "statusReason", "statusChangedAt"];
type ComparableAssetField = (typeof COMPARABLE_ASSET_FIELDS)[number];
export interface AssetChange {
    id: string;
    path?: string | undefined;
    changedFields: ComparableAssetField[];
    contentChanged?: boolean;
    from: AssetDelta;
    to: AssetDelta;
}
export interface EdgeDelta {
    source: string;
    target: string;
    kind: string;
    resolved: boolean;
    evidence?: EvidenceDelta | undefined;
}
interface ReadinessCheckChange {
    id: string;
    title: string;
    fromStatus: string;
    toStatus: string;
    fromSeverity: string;
    toSeverity: string;
    summaryChanged: boolean;
}
interface FindingDelta {
    id: string;
    severity: string;
    riskClass?: string | undefined;
    title: string;
    evidence?: EvidenceDelta | undefined;
    /** Retained for required-metadata or repository severity-policy evidence. */
    details?: Record<string, unknown> | undefined;
}
interface EvidenceDelta {
    path?: string | undefined;
    startLine?: number | undefined;
    endLine?: number | undefined;
    snippet?: string | undefined;
}
interface DiffSnapshot {
    ref: string;
    root: string;
    readiness: ReadinessReport;
    graph: GraphReport;
    discovery?: SkillDiscoveryIndex;
    executableSurfaceInventory?: ExecutableSurfaceInventory;
    securityPolicies?: SecurityPolicyAssetEvidence[];
    securityConfig?: SecurityConfig;
    qualityConfig?: QualityConfig;
    metadataConfig?: MetadataConfig;
    diagnosticsConfig?: DiagnosticsConfig;
    scanBoundary?: ScanBoundaryEvidence;
    inspectionCoverage?: InspectionCoverage;
    configPath?: string;
    suppressedFindings?: SuppressedFindingEvidence[];
}
export interface DiffCollectionInstrumentation {
    from?: RepositoryCollectionInstrumentation;
    to?: RepositoryCollectionInstrumentation;
}
interface DiffExecutionContext {
    report: DiffReport;
    skillDiscoveryCiPolicy: {
        from: SkillDiscoveryCiPolicyMode;
        to: SkillDiscoveryCiPolicyMode;
    };
    securityPolicyCiPolicy: {
        from: SecurityCiPolicyMode;
        to: SecurityCiPolicyMode;
    };
    scanBoundaryCiPolicy: {
        from: ScanBoundaryCiPolicyMode;
        to: ScanBoundaryCiPolicyMode;
    };
    executableSurfaceCiPolicy: {
        from: ExecutableSurfaceCiPolicyMode;
        to: ExecutableSurfaceCiPolicyMode;
    };
    qualityCiPolicy: {
        from: QualityCiPolicyMode;
        to: QualityCiPolicyMode;
    };
    metadataCiPolicy: {
        from: MetadataCiPolicyMode;
        to: MetadataCiPolicyMode;
    };
    diagnosticSeverityCiPolicy: {
        from: DiagnosticsCiPolicyMode;
        to: DiagnosticsCiPolicyMode;
    };
    effectiveCiScanBoundary?: EffectiveCiScanBoundaryEvidence;
}
interface DiffOptions {
    fromRef: string;
    toRef: string;
    overrides?: ConfigOverrides;
    instrumentation?: DiffCollectionInstrumentation;
    includeCiEvidence?: boolean;
}
export declare function runDiffCommand(targetPath: string, options: {
    fromRef: string;
    toRef: string;
    format: DiffFormat;
    overrides?: ConfigOverrides;
}): Promise<number>;
export declare function diff(targetPath: string, options: DiffOptions): Promise<DiffReport>;
/** @internal Execute one complete semantic diff while retaining CI-only ref evidence. */
export declare function executeDiff(targetPath: string, options: DiffOptions): Promise<DiffExecutionContext>;
/** @internal Build the Discovery-free projection for compatibility consumers. */
export declare function diffWithoutSkillDiscovery(targetPath: string, options: DiffOptions): Promise<DiffReportWithoutSkillDiscovery>;
export declare function buildDiffReport(root: string, fromSnapshot: DiffSnapshot, toSnapshot: DiffSnapshot): DiffReport;
export declare function formatDiff(report: DiffReportFormatInput, format: DiffFormat): string;
export declare function formatInspectionCoverageChange(change: InspectionCoverageChange): string;
export declare function formatSecurityChanges(security: SecurityDiffSummary | undefined): string[];
export {};