import type { WalkontableInstance } from './3rdparty/walkontable/src/types';
/**
 * A measurement-only ("shadow") probe of the rendered grid.
 *
 * The single-pass refactor moves content-driven size discovery out of the rendering engine. Today
 * Walkontable measures the rendered rows and headers mid-draw (`markOversizedRows` and
 * `syncOversizedColumnHeadersWithFrozenOverlays`, both in `axisSizing/oversizedRows`) and re-runs
 * its calculators in the same draw. The end
 * state supplies every size to the engine up front, so the engine renders once; whatever content
 * height cannot be known up front (wrapped cells and multi-line headers, with `AutoRowSize` off) is
 * discovered by this Handsontable-side probe after the draw and fed back into the next one.
 *
 * This class is the first, deliberately inert, step of that move. It runs after a full master draw
 * (from `TableView.afterRender`, the engine's `onDraw` callback, when the DOM is final), measures the
 * rendered row and column-header heights, and stores them in its own maps. It does NOT feed the
 * values into any size read and it does NOT trigger a re-draw — the engine's own oversized machinery
 * still owns the frame, unchanged. Consuming these values (and deleting the engine machinery) is the
 * next stage's work, gated behind the single-pass behavior change.
 *
 * Its only present job is to prove that an independent measurement produces the same numbers the
 * engine records in `wtViewport.oversizedRows` / `wtViewport.oversizedColumnHeaders`. The
 * characterization spec pins that equality, so the later deletion of the engine machinery rests on a
 * verified replacement. The row and header measurement math is a faithful copy of the engine methods
 * named above, including the border-box compensations.
 */
export declare class RenderSizeProbe {
    #private;
    /**
     * Measured row heights, keyed by the engine's source row index (equivalently, Handsontable's
     * renderable row index). Mirrors the values the engine writes to `wtViewport.oversizedRows` for the
     * rows it deems oversized; this map holds every rendered row, so the pinned subset is
     * `oversizedRows`'s keys.
     *
     * @type {Map<number, number>}
     */
    rowHeights: Map<number, number>;
    /**
     * Measured column-header row heights, keyed by header level. Mirrors the rendered THEAD row heights
     * the engine reads into `wtViewport.oversizedColumnHeaders`.
     *
     * @type {Map<number, number>}
     */
    columnHeaderHeights: Map<number, number>;
    /**
     * Measures the rendered grid and refreshes the stored maps. A pure read — no DOM writes, no size
     * feedback, no re-draw. Safe to call on every full draw.
     *
     * @param {WalkontableInstance} wt The Walkontable facade for the rendered instance.
     */
    measure(wt: WalkontableInstance): void;
    /**
     * Whether any measured column-header level is taller than the default header height, i.e. a
     * content-driven (or configured) header that the overlays must be re-synced to. Used to gate the
     * post-draw header reconcile so normal single-line headers pay nothing.
     *
     * @param {number} defaultHeight The default header (row) height in px.
     * @returns {boolean}
     */
    hasColumnHeaderTallerThan(defaultHeight: number): boolean;
}