import { type CodebaseIndex, type HashCodeSymbolsResult, type SymbolHashLineageResolution, type SymbolHashVerdict, type SymbolKeyQuery, type SymbolVerificationHashes } from './types.js';
export interface HashCodeSymbolsOptions {
    /**
     * Emit `normalized-equal` instead of the legacy `cosmetic-drift` label when
     * body bytes differ but normalized tokens match.
     * This is an identity heuristic only, never a semantic no-op claim. Defaults
     * to true as of 0.20; pass false for the legacy `cosmetic-drift` label.
     */
    normalizedEqualVerdict?: boolean;
    /**
     * Optional lineage lookup for a missing expected symbol.
     *
     * Absent by default so the ordinary hash path never builds or reads the
     * entity index. The CLI supplies it only for explicit `--resolve-gone`.
     */
    resolveGone?: (query: SymbolKeyQuery, expectedBodyHash: string) => Promise<SymbolHashLineageResolution> | SymbolHashLineageResolution;
}
/**
 * Batch body-hash primitive behind the `code.symbol.bodyHash` feature key.
 *
 * Resolution reuses the `readCodeSource` candidate matcher (`selectByQuery`),
 * narrowed by `containerName` when the query provides one. Each query is
 * independent: a bad query yields one `error`/`not_found` entry in the result
 * array (positionally aligned with `queries`), never a thrown batch.
 *
 * Frozen hash contract: `bodyHash` is the full 64-char lowercase hex sha256
 * over the UTF-8 bytes of the legacy `source` string `readCodeSource` returns
 * for the resolved node (the `lines.slice(line - 1, endLine)` join). No
 * truncation. Algorithm and normalization are part of the public contract;
 * changing either is a breaking change requiring a new feature key.
 */
export declare function hashCodeSymbols(index: CodebaseIndex, queries: SymbolKeyQuery[], _options?: HashCodeSymbolsOptions): Promise<HashCodeSymbolsResult[]>;
export declare function computeBodyHash(source: string): string;
/**
 * Stored expected tuple accepted by {@link compareSymbolHashTuples}.
 *
 * A superset of `SymbolKeyQuery['expected']`: the anchor-verification surface
 * additionally records `algo` at capture time and may hold a partial tuple
 * (`normalizedHash`/`structuralHash` absent for records whose extraction had
 * no body tier). The symbol-hash CLI keeps requiring the full triple.
 */
export interface SymbolHashExpectedTuple {
    bodyHash: string;
    normalizedHash?: string;
    structuralHash?: string;
    exactSpanHash?: string;
    hashVersion?: number;
    algo?: 'lexer' | 'declaration' | 'none';
}
export interface CompareSymbolHashTuplesOptions {
    /** Emit `normalized-equal` instead of the legacy `cosmetic-drift` label. Defaults to true. */
    normalizedEqualVerdict?: boolean;
}
/**
 * Mechanical comparison of one stored tuple with the current tiers.
 *
 * The exact-span shortcut runs first because raw sha256 byte equality is
 * version-independent proof. Every other tier is produced by the normalizing
 * lexer, so a `hashVersion` or `algo` mismatch refuses (`unknown-tier`) rather
 * than misreporting a version bump or an engine change as drift. A partial
 * tuple can still prove body equality (`fresh`) but never classify drift —
 * cosmetic-vs-semantic needs the normalized tier on both sides.
 */
export declare function compareSymbolHashTuples(current: SymbolVerificationHashes, expected: SymbolHashExpectedTuple, options?: CompareSymbolHashTuplesOptions): SymbolHashVerdict;
