/** FNV-1a 32-bit over a string, hex-encoded, with a length suffix so the
 * (tiny) collision surface also has to match on length. Used for text and
 * stylesheet digests — a comparison fingerprint, not a security hash. */
export declare function fnv1a32(text: string): string;
/** One element's structural fingerprint inside a captured page. */
export interface QaNodeSignature {
    /** Structural path from body: `body>div:0>table:1>tr:4>td:2` (index among
     * element siblings). Position-sensitive by design — reordering IS a
     * structural change. */
    path: string;
    tag: string;
    /** Canonical attribute string: sorted `name=value` pairs joined with \x1f.
     * Raw (not digested) so a reviewer can see WHICH attribute changed. */
    attrs: string;
    /** Digest of the element's direct text-node content (whitespace-normalized),
     * absent when the element has no direct text. */
    text?: string;
    /** Digest of opaque rendered content whose pixels can change without a DOM
     * structure or attribute change (for example SVG descendants or a canvas
     * bitmap). `unavailable` widens to unknown because text-only cannot be
     * proven without this evidence. */
    visual?: string;
    /** Nearest strict-ancestor stable anchor (unique `#id` or
     * `[data-qa-scope="…"]`), with the anchor element's own path so nested
     * anchors can be deduped to the outermost root. Absent for nodes with no
     * anchored ancestor (e.g. direct children of body on an anchor-free page). */
    anchor?: {
        selector: string;
        path: string;
    };
}
export interface QaStylesheetSignature {
    /** External sheet href, or `inline:<index>` for a `<style>` block. */
    key: string;
    kind: "external" | "inline";
    /** Content digest, or the literal `"unavailable"` when the sheet's text
     * could not be read (cross-origin without CORS). Unavailable digests widen
     * classification to `unknown` — style stability can't be proven. */
    digest: string;
}
/** A captured page signature: everything the classifier needs, nothing the
 * critique engine does. Produced by the browser client, persisted by the
 * snapshot store. */
export interface QaSignature {
    url: string;
    /** ISO capture time. */
    capturedAt: string;
    nodes: QaNodeSignature[];
    stylesheets: QaStylesheetSignature[];
    /** True when the capture hit its node cap. A truncated signature cannot
     * prove absence of change — the classifier widens to `unknown`. */
    truncated?: boolean;
}
export type ChangeClass = "text-data-only" | "local-visual" | "interaction-state" | "large-structural" | "unknown";
export interface QaScope {
    selector: string;
    reason: string;
    /** How many elements the selector matched at capture time (1 for anchors —
     * uniqueness is verified during capture; explicit selectors carry the
     * caller-counted value). */
    matches: number;
}
export interface QaClassification {
    /** `interaction-state` is never inferred from signatures — it is declared
     * by explicit state inputs at manifest time. */
    change_class: Exclude<ChangeClass, "interaction-state">;
    reasons: string[];
    /** Paths whose direct text content changed (structure + attrs identical). */
    text_changed_paths: string[];
    /** Paths added, removed, or with changed attributes. */
    structural_changed_paths: string[];
    /** Stylesheet keys whose digest changed, appeared, or disappeared. */
    stylesheets_changed: string[];
    /** Stable scope roots covering every structural change (local-visual only). */
    scopes: QaScope[];
    /** True when baseline and current are indistinguishable. */
    identical: boolean;
}
export interface ClassifyOptions {
    /** More distinct scope roots than this widens to large-structural: a change
     * that touches many independent regions is a page-level change no matter
     * how well-anchored each region is. Default 4. */
    maxScopes?: number;
}
/**
 * Classify current against baseline. Pure: no browser, no filesystem. The
 * bias is stated in the plan and enforced here — ambiguity widens (to
 * `unknown`/`large-structural`), never narrows. A `null` baseline is the
 * "no baseline available" case and is always `unknown`.
 */
export declare function classifySignatures(baseline: QaSignature | null, current: QaSignature, opts?: ClassifyOptions): QaClassification;
export interface QaContext {
    viewport: string;
    theme: "light" | "dark";
    state: string;
}
export interface QaManifest {
    schema_version: 1;
    change_class: ChangeClass;
    classification_reasons: string[];
    source_revision?: string;
    baseline_revision?: string;
    /** Which resolution-order source produced the baseline:
     * `qa-snapshot:<capturedAt>`, `production-render:<capturedAt>`,
     * `revision-render:<rev>`, or `none`. */
    baseline_source: string;
    scopes: QaScope[];
    contexts: QaContext[];
    checks: {
        deterministic: string[];
        /** Assertions that prove named interaction states behaved correctly. */
        interaction: string[];
        visual: "none" | "scoped" | "full-page";
    };
    concurrency: {
        headless: number;
        metered: number;
    };
    reuse: {
        mode: "none" | "exact-digest" | "band-diff";
        cache: boolean;
    };
    /** Provider-call ceiling for the plan, so cost is visible before execution.
     * Full-page tile counts need a rendered page; callers pass an estimate. */
    predicted: {
        tiles_ceiling: number;
        model_calls_ceiling: number;
    };
    /** Present when the run cannot produce a trustworthy verdict (e.g. unknown
     * class without permission to widen). An incomplete run is never a pass. */
    incomplete?: {
        reason: string;
    };
}
export interface ManifestOptions {
    baselineSource: string;
    sourceRevision?: string;
    baselineRevision?: string;
    /** Explicit scope selectors from the producing task — resolution order rung
     * 1; they override lifted anchors entirely. */
    explicitScopes?: QaScope[];
    /** Named interaction states to review (before/after pairs, etc.). Any
     * non-empty list promotes a text/local classification to
     * `interaction-state` and appends one context per state. */
    states?: string[];
    /** Viewports for the full matrix (default ["desktop", "mobile"]). */
    viewports?: string[];
    /** Estimated full-page tile count per context, from the caller's render
     * knowledge (page height / band step, capped). Default 24 (the tile cap). */
    estimatedFullPageTiles?: number;
    concurrency?: {
        headless: number;
        metered: number;
    };
    reuse?: {
        mode: "none" | "exact-digest" | "band-diff";
        cache: boolean;
    };
    deterministicChecks?: string[];
    /** Value/behavior assertions paired with explicit interaction states. */
    outcomeAssertions?: string[];
    /** When false (default), an `unknown` classification widens to full
     * large-structural coverage. When true, the manifest instead marks itself
     * incomplete with zero contexts — the caller wants a hard stop. */
    stopOnUnknown?: boolean;
}
/**
 * Turn a classification into an executable review manifest. Pure: rendering,
 * baseline acquisition, and critique execution stay in the caller. The
 * separation is the point — the manifest can be printed by a dry run,
 * reviewed, and overridden before expensive work starts.
 */
export declare function buildQaManifest(classification: QaClassification, opts: ManifestOptions): QaManifest;
//# sourceMappingURL=qa-plan.d.ts.map