/**
 * One signer as a node in the key and DID graph. A signer is whatever
 * produced a signature the verifier checked: an agent, a gateway, a
 * notary, an external anchor. `id` is its stable identity (public key hex
 * or DID). `chainsTo` lists the roots/anchors it directly depends on:
 * issuer DID, gateway root-of-trust fingerprint, JWKS origin, trust-anchor
 * key id. These are the edges the independence relation closes over.
 *
 * This is a verifier-side projection of facts already on the receipt and
 * in resolution results (e.g. a KeyResolution's selected kid / JWKS
 * origin). It carries no assurance level and no issuer claim.
 */
export interface SignerNode {
    /** Stable signer identity: Ed25519 public key hex, or a DID. */
    id: string;
    /** Anchors this signer directly chains to (issuer DID, gateway root,
     *  JWKS origin, trust-anchor fingerprint). Empty = no declared anchor. */
    chainsTo?: string[];
    /** Optional self-describing role, carried through for the descriptor.
     *  Never used to compute independence - only `id`/`chainsTo` are. */
    role?: string;
}
/**
 * The signer graph the verifier assembles before computing independence.
 * `nodes` are the signers. `anchorEdges` lets a caller express that two
 * anchors are themselves the same root (e.g. a gateway root that is also a
 * JWKS origin under a different label), without rewriting every node. Both
 * inputs are verifier-supplied facts, never issuer-supplied.
 */
export interface SignerGraph {
    nodes: SignerNode[];
    /** Equivalences between anchor identifiers: each pair names two anchor
     *  ids that denote the same root. Closed over transitively. */
    anchorEdges?: Array<[string, string]>;
}
/**
 * Result of the independence relation for one ordered (here symmetric)
 * pair of signers. `independent` is the headline yes/no. `sharedRoots`
 * names the common anchors when they are NOT independent, so a descriptor
 * can report WHY, never a score.
 */
export interface IndependenceRelation {
    signerA: string;
    signerB: string;
    /** True iff the two signers' anchor closures do not intersect. */
    independent: boolean;
    /** The anchors both signers reduce to. Empty iff independent. */
    sharedRoots: string[];
}
/**
 * sharesRoot: do two signers reduce to a common root in the key/DID graph?
 *
 * Returns the relation, including the shared anchors when they are not
 * independent. Reflexive: a signer always shares a root with itself.
 * Symmetric: the answer does not depend on argument order. Pure: identical
 * inputs always yield identical output, so the descriptor is reproducible.
 *
 * This is the only place independence is decided. It reads `id` and
 * `chainsTo` and nothing else - never an assurance level, never an
 * issuer-written field.
 */
export declare function sharesRoot(a: SignerNode, b: SignerNode, graph?: Pick<SignerGraph, 'anchorEdges'>): IndependenceRelation;
/**
 * All pairwise independence relations over a signer graph, in a stable
 * order (sorted by signer id, then partner id). Self-pairs are omitted -
 * a signer is trivially non-independent of itself and that fact carries no
 * descriptor signal. Distinct signers that share an `id` collapse to one
 * relation set keyed by first occurrence.
 *
 * Pure over the graph: the same graph always produces the same relations,
 * which is what lets the advisory scalar be reproducible from the
 * descriptor alone.
 */
export declare function allPairwiseIndependence(graph: SignerGraph): IndependenceRelation[];
/**
 * Count of signers that are independent of EVERY other signer in the graph
 * (no shared root with any peer). This is a mechanical census, not a grade:
 * it just reports how many fully-independent corroborators the evidence
 * carries. A lone signer trivially counts as 1.
 */
export declare function independentSignerCount(graph: SignerGraph): number;
//# sourceMappingURL=shares-root.d.ts.map