/** Known-good hashes per Lisa-owned destination path. */
export type HashLedger = Readonly<Record<string, readonly string[]>>;
/** What refresh concluded about a host's copy of a Lisa-owned artifact. */
export type ProvenanceVerdict = 
/** Byte-identical to Lisa's copy; there is nothing to decide. */
{
    readonly kind: "identical";
}
/** Declares hardening Lisa lacks. Preserve, and name what would be lost. */
 | {
    readonly kind: "host-ahead";
    readonly extraCapabilities: readonly string[];
}
/** Content Lisa never shipped. Preserve and report. */
 | {
    readonly kind: "host-modified";
}
/** Hash matches a Lisa release. Genuinely stale, so refresh it. */
 | {
    readonly kind: "provably-stale";
}
/** Artifact carries no provenance yet; behave exactly as before this change. */
 | {
    readonly kind: "unenrolled";
};
/**
 * The verdicts under which the host's copy is kept.
 *
 * Derived from `ProvenanceVerdict` rather than restated, so a verdict added
 * later cannot quietly go unhandled: `mayRefreshLisaOwned` must classify it, and
 * anything it declines to refresh has to be describable here.
 */
export type PreservedVerdict = Extract<ProvenanceVerdict, {
    readonly kind: "host-ahead" | "host-modified";
}>;
/**
 * Decide whether a host's copy of a Lisa-owned artifact may be overwritten.
 *
 * Order matters. Capabilities are consulted before the ledger because a
 * declaration is an explicit statement of intent by whoever edited the file, and
 * an explicit statement outranks an inference drawn from a hash table.
 * @param relativePath - Repo-relative destination path of the artifact
 * @param hostBytes - Contents currently installed in the host project
 * @param lisaBytes - Contents Lisa ships for that path
 * @param ledger - Known-good hash ledger (injected by tests)
 * @returns The verdict describing which side is ahead
 */
export declare function classifyHostCopy(relativePath: string, hostBytes: Buffer, lisaBytes: Buffer, ledger?: HashLedger): ProvenanceVerdict;
/**
 * Whether refresh is allowed to replace the host's copy.
 *
 * The default is deliberately asymmetric. Failing closed leaves a stale file in
 * place and tells somebody about it; failing open deletes a security control and
 * tells nobody. Those costs are not comparable, so anything short of proof that
 * the host is behind means the host's copy stays.
 * @param verdict - Result of `classifyHostCopy`
 * @returns True when the host copy is provably not ahead
 */
export declare function mayRefreshLisaOwned(verdict: ProvenanceVerdict): verdict is Exclude<ProvenanceVerdict, PreservedVerdict>;
/**
 * Explain a Lisa-owned file that could not be classified at all.
 *
 * Distinct from `describePreserved`, which reports a verdict. There is no
 * verdict here: one side's bytes could not be read, so nothing is known about
 * which copy is ahead. Saying "your copy is stronger" would be inventing a
 * finding, and saying "out of date" would be inventing the opposite one — so
 * this names the unreadable side and the one action that resolves it.
 * @param relativePath - Repo-relative destination path of the artifact
 * @param hostUnreadable - True when the project's copy is the unreadable side
 * @returns One operator-readable sentence
 */
export declare function describeUnclassifiable(relativePath: string, hostUnreadable: boolean): string;
/**
 * Explain a preserved file to whoever is reading the apply output.
 *
 * Written for an operator who did not make the change and may not be an
 * engineer: it names the file, says plainly that theirs is the stronger copy,
 * and gives the two actions that end the standoff.
 * @param relativePath - Repo-relative destination path of the artifact
 * @param verdict - Result of `classifyHostCopy`
 * @returns One operator-readable sentence, or undefined when nothing was held back
 */
export declare function describePreserved(relativePath: string, verdict: PreservedVerdict): string;
//# sourceMappingURL=lisa-owned-provenance.d.ts.map