/**
 * The capability marker a Lisa-owned guard uses to declare what it defends
 * against, so refresh can compare two copies by *what they stop* rather than by
 * bytes.
 *
 * A byte comparison answers "are these the same?" and nothing else. It cannot
 * answer the only question refresh actually needs answered — "is the host's copy
 * behind mine, or ahead of it?" — and guessing "behind" is how a host's stronger
 * guard gets silently replaced by a weaker upstream one.
 *
 * The marker is one comment line in the guard's header:
 *
 * ```
 * # lisa-guard-capabilities: no-verify-abbrev, hookspath-allowlist, config-env
 * ```
 *
 * Deliberately a *set*, not a version number. A monotonic `lisa-guard-version: N`
 * is easier to compare but lies the moment two hosts harden different vectors
 * independently — which is exactly what happened: `acmeorga/frontend` closed
 * the `GIT_CONFIG_KEY_<n>` bypass while `acmeorgd-infrastructure` closed a different
 * one. Both would have bumped to the same number and one would have silently
 * won. Two sets stay two sets, and set difference names precisely what each copy
 * has that the other does not.
 *
 * Only the header window is scanned. A guard whose *body* greps for the marker
 * string, or a test fixture that quotes one, must not be read as declaring it.
 * @module core/guard-capabilities
 */
/** A guard's declared capability set, normalised for comparison. */
export type CapabilitySet = ReadonlySet<string>;
/**
 * Read the capabilities a guard's header declares.
 *
 * Absence is not an error and not a failure signal — it means the artifact has
 * not been enrolled, and every caller treats that as "no declaration made"
 * rather than "declares nothing dangerous". That is what lets the marker roll
 * out one guard at a time with no flag day.
 * Scanned line by line with plain string operations rather than a regular
 * expression. A header is untrusted input — it arrives from whatever repository
 * the "host" copy came from — and a linear scan cannot be made to backtrack.
 * @param bytes - Full contents of the guard file
 * @returns The declared capabilities, lower-cased and de-duplicated
 */
export declare function readGuardCapabilities(bytes: Buffer): CapabilitySet;
/**
 * The capabilities the host declares that Lisa's copy does not.
 *
 * A non-empty result is the whole signal: the host copy defends something
 * upstream does not, so overwriting it removes protection. This is set
 * *difference*, not a strict-superset test, on purpose — a host that hardened
 * vector A while upstream hardened vector B is not a superset of upstream, yet
 * overwriting it still deletes A. Asking only "is the host a superset?" would
 * clobber precisely the divergent-hardening case the set representation exists
 * to handle.
 * @param host - Capabilities declared by the installed copy
 * @param lisa - Capabilities declared by the packaged copy
 * @returns Capabilities present on the host and absent upstream, sorted
 */
export declare function capabilitiesOnlyOnHost(host: CapabilitySet, lisa: CapabilitySet): readonly string[];
//# sourceMappingURL=guard-capabilities.d.ts.map