import type { ActionReceipt, Delegation, BeneficiaryTrace, AttributionReport, MerkleProof, BeneficiaryInfo } from '../types/passport.js';
export declare function hashReceipt(receipt: ActionReceipt): string;
/**
 * Follow the delegation chain from an action receipt back to the human who
 * authorized it. Reports two DISTINCT, honestly-named properties:
 *
 *   resolved  Lookup success only. Every hop's (from,to) key pair maps to a
 *             known delegation record AND the principal resolves to a known
 *             beneficiary. This proves the lineage RESOLVES against the supplied
 *             records, NOT that it is authentic: a creator-supplied chain that
 *             happens to match known records can be `resolved`. Do not trust it
 *             as proof of authorization.
 *
 *   verified  Cryptographic verification. The receipt signature is authentic
 *             (checked with verifyReceipt against the executor at the chain
 *             tail) AND every delegation in the traced lineage passes
 *             verifyDelegation (its own ed25519 signature by its delegator is
 *             valid and it is within its validity window). A tampered or forged
 *             chain CANNOT be `verified`: a hop whose delegator key the caller
 *             does not hold fails verifyDelegation. This reuses the canonical
 *             verifiers and does not reimplement crypto.
 *
 *             Scope of the claim: `verified` attests that the lineage signatures
 *             are authentic and temporally valid. It does NOT check that the
 *             action was authorized (scopeUsed within the delegation scope) or
 *             that scope narrows between hops (use verifyDelegationChain /
 *             scopeAuthorizes), and it does NOT consult revocation
 *             (verifyDelegation runs fail-open on this path unless the caller
 *             threads a revocation cache).
 *
 * Every agent action resolves to a human. `verified` is the field to trust;
 * `resolved` is a convenience lookup that makes no cryptographic claim.
 */
export declare function traceBeneficiary(receipt: ActionReceipt, delegations: Delegation[], beneficiaryMap: Map<string, BeneficiaryInfo>): BeneficiaryTrace;
export declare function verifyAttributionReport(report: AttributionReport, publicKey: string): {
    valid: boolean;
    errors: string[];
};
/**
 * Build a Merkle root from leaf hashes.
 * Leaves are sorted for determinism — same set always produces same root.
 * Odd levels duplicate the last node (standard Bitcoin-style).
 */
export declare function buildMerkleRoot(leafHashes: string[]): string;
/**
 * Generate an inclusion proof for one receipt in the tree.
 * Returns the sibling hashes needed to recompute the root.
 */
export declare function generateMerkleProof(leafHashes: string[], targetHash: string): MerkleProof | null;
/**
 * Verify a Merkle inclusion proof.
 * Recompute the root from the leaf + proof, compare against claimed root.
 */
export declare function verifyMerkleProof(proof: MerkleProof): boolean;
export declare const DEFAULT_SCOPE_WEIGHTS: Record<string, number>;
export declare function computeAttribution(..._args: unknown[]): never;
export declare function computeCollaborationAttribution(..._args: unknown[]): never;
//# sourceMappingURL=attribution.d.ts.map