/**
 * The class graph-visualizer.ts stamps on the invisible rank anchors, spacer bands and ordering
 * edges that pin each level to its own row. They are layout scaffolding, not architecture, so the
 * indexes below skip them: an anchor must never be walkable as a dependency, or hovering one box
 * would light boxes it has nothing to do with.
 *
 * Graphviz drops `style=invis` elements from its SVG entirely (verified against the emitted SVG),
 * so today nothing carrying this class reaches the DOM at all. The skip is the guarantee that the
 * scaffolding stays inert if that ever stops being true — the DOT is the only place that decides
 * what is scaffolding, and it says so with this class.
 */
declare const LAYOUT_CLASS = "wp-layout";
/** One traversal direction: the edges to light, and the nodes to walk on to. */
declare class Direction {
    readonly nodes: Map<string, Set<string>>;
    readonly edges: Map<string, Set<Element>>;
    constructor(nodes: Map<string, Set<string>>, edges: Map<string, Set<Element>>);
}
/**
 * Indexes the rendered SVG and drives the dim/highlight/lock interaction.
 *
 * The adjacency is DIRECTED and kept as two maps per axis: `in*` is what points AT a node (ancestors,
 * walked upward) and `out*` is what it points to (dependencies, walked downward). Highlighting walks
 * both, so a hovered box lights its entire chain in both directions rather than just its neighbours.
 */
declare class GraphHighlighter {
    private readonly svg;
    private readonly nodeByName;
    private readonly inEdges;
    private readonly outEdges;
    private readonly inNodes;
    private readonly outNodes;
    /**
     * The box the dropdown pinned, or null. Hover still works on top of a lock — leaving a box
     * restores the LOCKED view instead of clearing, so the pinned subgraph stays visible while you
     * scroll down to its responsibility cards.
     */
    private locked;
    constructor(svg: SVGSVGElement);
    /** Index the SVG, then wire hover, the lock dropdown, and the per-node floating menu. */
    wire(): void;
    private indexNodes;
    private indexEdges;
    private ensureEdges;
    private ensureNodes;
    private clear;
    /**
     * Dim everything, then transitively light ancestors and descendants of `name`: edges reached get
     * `wp-hl`, boxes get `wp-neighbor`. The `visited` set is what makes a cyclic graph terminate.
     */
    private highlight;
    private walk;
    /** Leaving a box restores the locked view rather than clearing it outright. */
    private relight;
    private wireHover;
    private wireLock;
    private lockSelect;
    /** True when `name` is the box the page is currently locked on — what the menu labels itself by. */
    isLocked(name: string): boolean;
    /**
     * THE one lock entry point, so the dropdown and the node menu can never disagree: it sets the
     * dropdown's selection, re-highlights, and re-filters the cards whichever of the two asked.
     * `null` is "All (no lock)".
     */
    setLock(name: string | null): void;
    private applyLock;
    /**
     * Every box opens the floating menu (the shared one both generated graphs use). "View Design" is
     * only built when that project actually HAS a committed design.html; the bottom item is always
     * Lock or Unlock, whichever applies to this box right now.
     */
    private wireMenu;
    /**
     * Filter the responsibility cards to the locked box's chain by READING BACK the
     * `.wp-focus`/`.wp-neighbor` classes highlight() just set — so there is no second graph walk and
     * the cards can never disagree with the picture.
     */
    private filterCards;
}
/** Renders the DOT and hands the SVG to the highlighter. Reports a failure into the page, not just the console. */
declare class GraphPage {
    render(): void;
}