/**
 * StandardsEnforcementAuditor — the registry-wide enforcement-coverage audit
 * (cartographer-conformance-audit spec #3, Parts B + C).
 *
 * For each constitutional standard in `docs/STANDARDS-REGISTRY.md`, it:
 *   1. parses the article (StandardsRegistryParser),
 *   2. extracts the enforcement references its prose NAMES (StandardEnforcementExtractor),
 *   3. VERIFIES each reference resolves against the live repo — a file via
 *      `fs.existsSync`, a route via a regex scan of `src/server/routes.ts`, a
 *      symbol/marker via a bounded grep of `src/**`,
 *   4. classifies the standard by its STRONGEST verified guard
 *      (`ratchet` > `gate` > `lint` > `spec-only` > `documented-only` gap),
 *   5. records DANGLING refs — a guard a standard names that no longer exists on
 *      disk (a broken guarantee, the loudest signal).
 *
 * Deterministic + idempotent: two runs over an unchanged registry+repo produce a
 * byte-identical report (refs are sorted; classifiedAt is omitted from the hashable
 * core). A content-hash short-circuit (registry hash + a cheap repo-structure signal)
 * skips recompute when nothing changed — the `docs-coverage.mjs` pattern.
 *
 * Observe-only, non-gating: it NEVER blocks anything. It produces a read-only
 * coverage report. "Signal vs. Authority" — a gap is a signal to build a guard.
 */
export type EnforcementKind = 'ratchet' | 'gate' | 'lint' | 'spec-only' | 'documented-only';
export interface VerifiedGuard {
    /** The reference token (path / `METHOD /route` / symbol). */
    ref: string;
    /** Recognizer kind from extraction. */
    kind: 'file' | 'route' | 'marker';
    /** Did the reference resolve on disk / in the route table / in src? */
    verified: boolean;
    /** The classification weight this guard contributes (only when verified). */
    guardKind?: Exclude<EnforcementKind, 'documented-only'>;
}
export interface StandardCoverage {
    standard: string;
    family: string;
    enforcementKind: EnforcementKind;
    guards: VerifiedGuard[];
    /** Refs named in prose but NOT found on disk — broken guarantees (loud signal). */
    danglingRefs: string[];
    classifiedAt: string;
}
export interface CoverageSummary {
    total: number;
    byKind: Record<EnforcementKind, number>;
    /** (ratchet + gate + lint) / total — the fraction of standards with a verified structural guard. */
    enforcedRatio: number;
    /** Names of `documented-only` standards (the gaps). */
    gaps: string[];
    /** Total dangling refs across all standards. */
    danglingCount: number;
}
export interface CoverageReport {
    generatedAt: string;
    /** Hash of the inputs (registry content + repo-structure signal) — drives the short-circuit. */
    inputHash: string;
    standards: StandardCoverage[];
    summary: CoverageSummary;
}
export interface AuditorOptions {
    /** Path to docs/STANDARDS-REGISTRY.md. */
    registryPath: string;
    /** Repo root — all refs resolve relative to this. */
    projectDir: string;
}
/** Compute the input hash that drives the recompute short-circuit. */
export declare function computeInputHash(opts: AuditorOptions): string;
/**
 * Compute the full enforcement-coverage report. Deterministic: the per-standard order
 * follows the registry parse order; refs within a standard are sorted; the only
 * non-deterministic field is `generatedAt`/`classifiedAt` (a timestamp, excluded from
 * `inputHash`). Pass `prior` to short-circuit when the input hash is unchanged.
 */
export declare function computeCoverage(opts: AuditorOptions, prior?: CoverageReport | null): CoverageReport;
/** A stable, timestamp-free view used to assert determinism (two runs → identical). */
export declare function stableView(report: CoverageReport): unknown;
//# sourceMappingURL=StandardsEnforcementAuditor.d.ts.map