import type { ColumnDef } from '../types/column.types';
import { HeaderIconDisplay } from '../types/column.types';
import type { GridStore } from '../core/grid-store';
import type { EventBus } from '../event-bus/event-bus';
import type { IconRenderer } from '../icons/icon-renderer';
import type { ColumnModel } from '../core/column-model';
import type { SortEngine } from '../engines/sort/sort-engine';
import type { GroupDropZone } from './group-drop-zone';
import type { ColumnGroupModel } from '../column-groups/column-group-model';
import type { ColumnGroupHeaderBuilder } from '../column-groups/column-group-header-builder';
import type { ColumnGroupDragHandler } from '../column-groups/column-group-drag-handler';
import type { DisplayGroupEngine } from '../column-groups/display-group-engine';
import { ColumnStyleManager } from './column-style-manager';
export interface HeaderRendererOptions {
    showCheckboxes?: boolean;
    showSerialNumber?: boolean;
    showFilterRow?: boolean;
    showColumnMenu?: boolean;
    headerRowHeight?: number;
    filterRowHeight?: number;
    hasGroupedColumns?: boolean;
    autoGroupColWidth?: number;
    /** Grid-wide default display mode for the filter funnel icon. @default HeaderIconDisplay.ALWAYS */
    filterIconDisplay?: HeaderIconDisplay;
    /** Grid-wide default display mode for the column-menu "⋯" icon. @default HeaderIconDisplay.ALWAYS */
    menuIconDisplay?: HeaderIconDisplay;
}
export declare class HeaderRenderer {
    private store;
    private eventBus;
    private iconRenderer;
    private columnModel;
    private sortEngine;
    private colStyles;
    private leftHeaderRowEl;
    private centerHeaderRowEl;
    private rightHeaderRowEl;
    private leftFilterRowEl;
    private centerFilterRowEl;
    private rightFilterRowEl;
    private headerCheckbox;
    private columnMenu;
    private groupContextMenu;
    private groupDropZone;
    /** Tree model for the column group hierarchy. `null` until wired via `setColumnGroupModel`. */
    private groupModel;
    /** DOM builder for multi-row grouped header rows. `null` until wired. */
    private groupHeaderBuilder;
    /** Group header row elements per panel — indexed 0..maxDepth-1. */
    private leftGroupRowEls;
    private centerGroupRowEls;
    private rightGroupRowEls;
    /**
     * Callback invoked when the user clicks a group collapse/expand toggle.
     * Provided by `GridRenderer` so it can coordinate header + body rebuild.
     */
    private onGroupToggleFn;
    /**
     * Callback invoked when the user finishes dragging a group resize handle.
     * `GridRenderer` wires this to distribute the delta and trigger reflow.
     */
    private onGroupResizeFn;
    /**
     * Wired by `GridRenderer` after group model setup — used in `onGlobalMouseUp`
     * to create a clone group when a leaf is dropped onto a different group header.
     */
    private groupDragHandler;
    /**
     * Display Group Engine — the new architecture that replaces ColumnGroupModel.
     * When set, `renderInPanels` uses this engine instead of the legacy model.
     */
    private displayGroupEngine;
    /**
     * Cached header row height from the last `renderInPanels` / `updateCenterVisibleCols`
     * call.  Used by `rebuildGroupRowsForPanel` which is called during drag when
     * `HeaderRendererOptions` is not available on the call stack.
     */
    private lastGroupRowHeight;
    private draggingColId;
    private isDragging;
    private draggingPanelRowEl;
    private draggingIsGroupable;
    private isOverGroupZone;
    /**
     * Positions the drag chip with a compositor-only transform.
     *
     * Replaces the previous `style.left` / `style.top` writes, which dirtied layout
     * on every pointer event and — because the handler then read the grid's rect
     * back — forced a synchronous layout flush each time.
     */
    private readonly dragGhost;
    /**
     * Owns the `<style>` element carrying the live `--pg-drag-x` rules, and skips
     * the assignment whenever the generated CSS is unchanged.
     *
     * This is the subsystem's largest single win: during a column drag the grid
     * renders *every* column (see `GridRenderer`'s drag-time column-buffer
     * expansion), so each `[data-col-id]` rule matches a header cell, a filter
     * cell, and every rendered body cell. Re-parsing that sheet several times per
     * frame recalculated style across the whole grid for a drop slot that had not
     * moved.
     */
    private readonly dragStyles;
    private draggingGridEl;
    private draggedColWidth;
    private dragStartScrollX;
    private dragIsHideMode;
    private dragSourcePanel;
    private dragTargetPanel;
    private dragTargetLocalIdx;
    private panelDragData;
    /**
     * Grid bounds captured at drag start and refreshed only when the layout moves.
     *
     * The outside-the-grid test used to call `getBoundingClientRect()` on every
     * pointer event, immediately after writing the chip's position — the textbook
     * write→read pair that forces layout.
     */
    private dragGridRect;
    /**
     * Coalesces `pointermove` into one frame of work.
     *
     * A mouse polls at 125–1000 Hz; the display paints at 60–120 Hz. Everything
     * this drag does — panel resolution, slot hit-testing, group-row preview,
     * CSS generation — now runs once per painted frame against the newest sample
     * instead of once per event.
     */
    private readonly dragFrames;
    /** Mirror of `document.body.style.cursor`, so an unchanged value is never rewritten. */
    private lastBodyCursor;
    private livePanelMoveInProgress;
    /**
     * `true` from the moment `pointerup` starts committing the drop.
     *
     * The commit path owns the column's final placement; a live cross-panel move
     * started after that point would race it with a second, conflicting model
     * mutation.
     */
    private dragFinishing;
    private scrollByX;
    private canScrollX;
    private onResizeCb;
    private autoScrollRAF;
    private autoScrollSpeed;
    private centerPanelRect;
    /** Last known cursor X during column drag — used to replay `onDragMove` after auto-scroll ticks. */
    private lastDragClientX;
    private boundMouseMove;
    private boundMouseUp;
    /** Callback wired by GridRenderer to open a filter panel for a column. */
    private openFilterPanelFn;
    /**
     * Callback wired by GridRenderer to apply a live, per-column text filter as the
     * user types in an inline filter-row input. Receives the empty string when the
     * input is cleared so the column filter can be removed.
     */
    private applyInlineFilterFn;
    /** Callback wired by GridRenderer to open the Column Chooser dialog. */
    private openColumnChooserFn;
    /** Callback wired by GridRenderer to re-run the data pipeline (e.g. after an aggregate change). */
    private columnDataRefreshFn;
    /**
     * Callback wired by GridRenderer to scroll a (possibly virtualized) center
     * column into view so keyboard header navigation can focus it.
     */
    private ensureColumnVisibleFn;
    /**
     * Column id of the header cell that participates in the tab order (roving
     * tabindex). All other header cells are `tabindex="-1"`. `null` until the
     * first render resolves it to the first visible data column. See
     * {@link setRovingCell} and {@link buildHeaderCell}.
     */
    private rovingColId;
    /** Read by grid-renderer's columns-store watcher to skip header destroy during drag */
    get isDraggingCol(): boolean;
    /**
     * The `colId` currently being dragged, or `null` when no column drag is live.
     *
     * `GridRenderer` reads this each render to pin the grabbed column into the
     * virtual column range: auto-scroll can carry its real position outside the
     * viewport while the pointer still holds it, and an evicted cell would leave
     * the drag without its subject. The row drag solves the same problem the same
     * way — see `RowDragRenderer.getDraggingNodeId`.
     */
    get draggingColumnId(): string | null;
    /**
     * `true` for exactly the synchronous window in which a finished column drag
     * writes its result into the column model.
     *
     * The store watcher fires re-entrantly from those writes, and it needs to tell
     * "the user just dropped this column" apart from "something moved the columns
     * on its own". A drop has already animated, live, under the pointer; replaying
     * that motion as a FLIP once the model catches up shows the user the same
     * movement twice. Anything that changes columns *without* a drag — a hide from
     * the context menu, the column chooser, a programmatic `moveColumn` — still
     * animates, because there the movement is the only feedback there is.
     *
     * @see cleanupDrag
     */
    get isCommittingColumnDrop(): boolean;
    /** Backing flag for {@link isCommittingColumnDrop}. */
    private committingDrop;
    /**
     * `true` while the header owns the pointer for a column reorder or resize.
     * The ScrollController's touch-pan yields to this (see `setGestureGuard`) so a
     * long-press reorder or an edge resize is never fought by kinetic scrolling.
     */
    get isBusy(): boolean;
    /** True while the user holds the resize handle and is actively moving the mouse. */
    private _isResizingColumn;
    /** Column id and timestamp of the last resize-handle press, for double-click (auto-size) detection. */
    private lastResizeDownColId;
    private lastResizeDownAt;
    /**
     * `true` between the resize-handle `mousedown` and the corresponding `mouseup`.
     * Grid-renderer uses this to suppress body `renderRows` during resize — column
     * widths are driven by CSS rules from `ColumnStyleManager`, so the body DOM
     * never needs to be rebuilt while the user is dragging a resize handle.
     */
    get isResizingColumn(): boolean;
    constructor(store: GridStore, eventBus: EventBus, iconRenderer: IconRenderer, columnModel: ColumnModel, sortEngine: SortEngine, colStyles: ColumnStyleManager);
    setScrollCallback(fn: (dx: number) => void, canScrollX?: (dir: 1 | -1) => boolean): void;
    setResizeCallback(cb: () => void): void;
    /**
     * Register the callback invoked when the user clicks the filter icon on a
     * filterable column header.  Wired by `GridRenderer.buildLayout()`.
     *
     * @param fn - Opens/positions a `FilterPanel` for the given column.
     */
    setOpenFilterPanelCallback(fn: (colDef: ColumnDef, anchorEl: HTMLElement) => void): void;
    /**
     * Register the callback invoked as the user types in an inline filter-row
     * input, applying a live per-column text filter. Wired by
     * `GridRenderer.buildLayout()`. Only fires for free-text (non set-type) columns
     * — set-type columns (see {@link SET_FILTER_TYPES}) filter through the panel.
     *
     * @param fn - Applies (or clears, on empty term) the column's text filter.
     */
    setInlineFilterCallback(fn: (colDef: ColumnDef, term: string) => void): void;
    /**
     * Registers the callback that opens the Column Chooser dialog, invoked from
     * the column menu's and group menu's "Column Chooser…" items.
     *
     * @param fn - Opens the chooser (owned by `GridRenderer`).
     */
    setColumnChooserCallback(fn: () => void): void;
    /**
     * Registers a callback that re-runs the grid's data pipeline (filter → sort →
     * group → aggregate). Invoked after a column aggregate function changes so
     * group aggregations recompute immediately when grouping is active.
     *
     * @param fn - Runs the pipeline + render (typically `GridApi.refresh`).
     */
    setColumnDataRefreshCallback(fn: () => void): void;
    /**
     * Register the callback that scrolls a center column into view. Invoked during
     * keyboard header navigation before focusing a column that may currently be
     * virtualized out of the DOM.
     *
     * @param fn - Reveals the column (typically `GridRenderer.ensureColumnVisible`).
     */
    setEnsureColumnVisibleCallback(fn: (colId: string) => void): void;
    /**
     * Configure the column context menu (sections, suppressed items, custom items,
     * right-click behaviour). Forwarded to the internal {@link ColumnMenu}.
     *
     * @param cfg - Grid-wide column-menu configuration.
     */
    setMenuOptions(cfg: import('../types/column-menu.types').ColumnMenuConfig): void;
    /**
     * Register the AG-Grid-style `getColumnMenuItems` transform. Forwarded to the
     * internal {@link ColumnMenu}.
     *
     * @param fn - Final item-list transform, or `undefined` to clear.
     */
    setColumnMenuItemsCallback(fn: import('../types/column-menu.types').GetColumnMenuItems | undefined): void;
    /**
     * Provide the grid's public API to the column menu, forwarded to custom-item
     * actions via {@link import('../types/column-menu.types').ColumnMenuItemContext}.
     *
     * @param api - The owning grid's `GridApi` (typed `unknown` to avoid a cycle).
     */
    setMenuApi(api: unknown): void;
    /**
     * Wire the column-group model and DOM builder into the header renderer.
     *
     * Call this before the first `renderInPanels` when the grid's column
     * definitions contain groups (i.e. `ColumnDef.children` is present on any
     * top-level column).  Once wired, `renderInPanels` and `updateCenterVisibleCols`
     * automatically insert and update the multi-row grouped header rows.
     *
     * @param model   - The live {@link ColumnGroupModel} for the grid.
     * @param builder - The {@link ColumnGroupHeaderBuilder} instance.
     */
    setColumnGroupModel(model: ColumnGroupModel, builder: ColumnGroupHeaderBuilder): void;
    /**
     * Wire the new Display Group Engine into the header renderer.
     * When set, `renderInPanels` uses the engine's builder instead of the legacy
     * `ColumnGroupModel` + `ColumnGroupHeaderBuilder`.
     *
     * @param engine - The fully-initialised `DisplayGroupEngine` instance.
     */
    setDisplayGroupEngine(engine: DisplayGroupEngine): void;
    /**
     * Register the callback fired when a user toggles a group's collapse state.
     *
     * `GridRenderer` wires this to coordinate header rebuild + leaf-column
     * visibility update in `ColumnModel`.
     *
     * @param fn - Receives the `groupId` of the toggled group.
     */
    setGroupToggleCallback(fn: (groupId: string) => void): void;
    /**
     * Register the callback fired when a user finishes dragging a group resize handle.
     *
     * `GridRenderer` wires this to call {@link ColumnGroupModel.distributeResizeDelta}
     * and flush the updated widths to `ColumnStyleManager`.
     *
     * @param fn - Receives `groupId` and the new desired total group width.
     */
    setGroupResizeCallback(fn: (groupId: string, newWidth: number) => void): void;
    /**
     * Wire the group drag handler so that leaf drops on foreign group header cells
     * create solo clone groups instead of doing a plain column reorder.
     *
     * @param handler - The active `ColumnGroupDragHandler` instance.
     */
    setGroupDragHandler(handler: ColumnGroupDragHandler): void;
    /**
     * Rebuild only the group-header rows for all panels without touching the leaf
     * row or filter row.  Call this after a group collapse/expand event has already
     * been processed by the model (i.e. `group.collapsed` flag is up to date).
     *
     * @param options - Header renderer options (passed from last `renderInPanels` call).
     */
    rebuildGroupRows(options: HeaderRendererOptions): void;
    /**
     * Updates the filter-active indicator (`pg-th--filter-active` class and icon
     * swap) on every rendered header cell based on the current `FilterModel`.
     * Called from the renderer's `filterModel` store watcher.
     *
     * @param activeColIds - Set of `colId` strings that currently have an active filter.
     */
    updateFilterIndicators(activeColIds: Set<string>): void;
    /**
     * Build the {@link GroupCellBuildOptions} object forwarded to the DOM builder.
     * Wires the toggle and resize callbacks registered by `GridRenderer`.
     */
    private buildGroupCellOptions;
    renderInPanels(leftContainer: HTMLElement, centerInnerEl: HTMLElement, rightContainer: HTMLElement, allColumns: ColumnDef[], options?: HeaderRendererOptions): void;
    updateSortIndicator(colId: string, order: 'asc' | 'desc' | null): void;
    updateAllChecked(isAll: boolean, isIndeterminate: boolean): void;
    setGroupDropZone(zone: GroupDropZone): void;
    destroy(): void;
    updateCenterVisibleCols(visibleCols: ColumnDef[], leftSpacerW: number, rightSpacerW: number, options: HeaderRendererOptions): void;
    /** Built centre header cells, keyed by `colId`, with the def they were built from. */
    private readonly centerThCache;
    /** Built centre filter cells, keyed by `colId`, with the def they were built from. */
    private readonly centerFilterCache;
    /** Reused spacer elements, keyed by slot, with the width they currently carry. */
    private readonly spacerCache;
    /** Reused auto-group cells, with the width they currently carry. */
    private autoGroupTh;
    private autoGroupFilterCell;
    /**
     * The centre header cell for `col`, built on first use and reused afterwards.
     *
     * @param col          - Column definition for this slot.
     * @param index        - Position within `panelColumns`, published as `data-col-index`.
     * @param panelColumns - The panel's ordered visible columns.
     * @param options      - Current header options.
     */
    private ensureCenterTh;
    /**
     * The centre filter cell for `col`, built on first use and reused afterwards.
     *
     * @param col - Column definition for this slot.
     */
    private ensureCenterFilterCell;
    /**
     * A reused spacer standing in for the off-screen columns on one side.
     *
     * @param slot  - Cache key identifying which spacer this is.
     * @param cls   - Class list for the element.
     * @param width - Width in CSS pixels.
     */
    private ensureSpacer;
    /**
     * The reused auto-group header cell.
     *
     * @param width - Width in CSS pixels.
     */
    private ensureAutoGroupTh;
    /**
     * The reused auto-group filter cell.
     *
     * @param width - Width in CSS pixels.
     */
    private ensureAutoGroupFilterCell;
    /**
     * Drops cached cells for columns that have scrolled out of the rendered range.
     *
     * Without this the caches would grow to hold a detached element for every
     * column the user has ever scrolled past — a leak proportional to the column
     * count on a wide grid.
     *
     * @param visibleCols - Columns currently in the rendered range.
     */
    private evictUnusedCenterCells;
    /** Discards every reused centre cell, forcing a full rebuild on the next render. */
    private clearCenterCellCaches;
    private makeSpacer;
    private capturePanelDragData;
    private buildHeaderRow;
    /**
     * Attach the delegated keyboard handler for a panel's header row. Implements
     * the WAI-ARIA grid-header keyboard model:
     *
     * - **ArrowLeft / ArrowRight** — move the roving focus to the previous / next
     *   visible column (spanning left → center → right panels).
     * - **Home / End** — move to the first / last visible column.
     * - **Enter / Space** — toggle the column's sort (when sortable).
     * - **Alt + ArrowDown** — open the column's filter panel.
     * - **Shift + F10** or the **ContextMenu** key — open the column context menu.
     *
     * Tab is intentionally not intercepted — the roving tabindex makes Tab exit the
     * header after a single stop.
     *
     * @param row - The panel header row element to delegate from.
     */
    private attachHeaderKeydown;
    private onHeaderKeydown;
    /**
     * Move the roving header focus by `dir` columns from `fromColId`, in the grid's
     * visible-column order (which spans the pinned-left, center, and pinned-right
     * panels). Clamped at both ends.
     */
    private moveRoving;
    /** Move the roving header focus to the first or last visible column. */
    private moveRovingToEdge;
    /**
     * Make `colId` the roving header cell (the single tab stop) and move DOM focus
     * to it. Updates every rendered header cell's tabindex across the three panels.
     * When the target is a virtualized center column not currently in the DOM, it
     * is first scrolled into view via the ensure-visible callback, then focused on
     * the next frame.
     *
     * @param colId - The column whose header cell should receive focus.
     */
    setRovingCell(colId: string): void;
    /**
     * Make `colId` the single header tab stop, without moving DOM focus.
     *
     * Split out of {@link setRovingCell} because the two callers need different
     * halves: arrow-key navigation wants the tabindex swap *and* the focus move,
     * while the `focusin` handler is already inside the focus it would otherwise
     * re-issue. Both must do the attribute swap, though — recording
     * {@link rovingColId} alone leaves `tabindex="0"` on the previously roving
     * cell, so tabbing out of the header and back returns to that stale cell
     * instead of the one the user last used.
     *
     * The sweep spans all three panel rows, so a column that moved between panels
     * (pinning) is still found.
     */
    private syncRovingTabindex;
    /** Locate a rendered header cell by column id across all three panels. */
    private findHeaderCell;
    /**
     * Guarantee exactly one header cell is in the tab order after a (re)render.
     * If the roving column is not currently rendered (e.g. virtualized out during
     * horizontal scroll), promote the first rendered data cell so Tab can always
     * reach the header.
     */
    private ensureRovingTabstop;
    private buildAutoGroupTh;
    /**
     * Build the leading spacer cell for the filter row that reserves the same
     * horizontal space as the auto-group header column ({@link buildAutoGroupTh}).
     *
     * The width must be applied explicitly — with no width the flex cell collapses
     * to its content, pushing every subsequent filter input out of alignment with
     * its header. Mirrors the header cell's inline sizing so the two rows track the
     * same `autoGroupColWidth`.
     *
     * @param width - The auto-group column width in pixels.
     * @returns A zero-content filter cell sized to the group column.
     */
    private buildAutoGroupFilterCell;
    private buildCheckboxHeaderCell;
    private buildSerialHeaderCell;
    private buildHeaderCell;
    /**
     * Advance a column's sort through the asc → desc → none cycle and update the
     * model, engine, and header indicator. Shared by the header-cell click handler
     * and keyboard activation (Enter / Space).
     *
     * @param col - The column to (re)sort. A no-op when `col.sortable === false`.
     */
    private toggleSort;
    /**
     * Column data types whose inline filter is a checkbox **set** dropdown rather
     * than a free-text term. Their filter-row input is rendered read-only (with a
     * disabled appearance) and opens the set-filter panel on click; free-text
     * columns instead filter live as the user types.
     */
    private static readonly SET_FILTER_TYPES;
    /** `true` when a column's inline filter should be a set (checkbox) dropdown. */
    private isSetFilterColumn;
    private buildFilterCell;
    private buildFilterRow;
    private attachColumnDragListeners;
    private startColumnDrag;
    /**
     * Writes `document.body.style.cursor` only when it differs from the value
     * already applied.
     *
     * The move handler re-asserted `'grabbing'` on every pointer event, and a style
     * write on `<body>` invalidates style for the document root — free to skip when
     * nothing changed.
     *
     * @param cursor - The cursor keyword, or `''` to restore the default.
     */
    private setBodyCursor;
    /**
     * When the cursor crosses into a new panel:
     * 1. Immediately DOM-move the source TH into the target panel header row
     * 2. Call moveAndPin() so body cells and panel widths update via the guarded re-render
     * 3. After 2 frames (re-render complete), re-capture rects and continue drag
     */
    private moveToPanelLive;
    private readonly tickAutoScroll;
    private updateAutoScroll;
    private stopAutoScroll;
    /**
     * Re-captures header column rects and re-applies drag transforms after each
     * auto-scroll step.  Runs 2 animation frames after the scroll so the grid's
     * virtual column render (`updateCenterVisibleCols`) has completed and the DOM
     * reflects any newly visible columns before `getBoundingClientRect` is called.
     *
     * This mirrors the 2-frame pattern used by `moveToPanelLive` and ensures the
     * dragged-column ghost and sibling transforms stay accurate even when the
     * mouse is stationary at the viewport edge while auto-scroll is running.
     */
    private refreshDragAfterScroll;
    /**
     * Rebuild the group header rows for one panel using a new (possibly preview)
     * column order.  Safe to call during drag — only the group row `<div>`s are
     * replaced; the leaf row `<tr>` that carries the live drag element is untouched.
     *
     * @param panel - Which panel's group rows to refresh.
     * @param cols  - Ordered visible columns for this panel (preview or committed).
     */
    private rebuildGroupRowsForPanel;
    /**
     * Compute the preview column order for the drag source panel (same-panel drag)
     * and rebuild its group rows.
     *
     * Called from `onDragMove` whenever the effective drop slot changes.  Always
     * derives the preview from the captured `panelDragData` colIds so the
     * `LogicalGroupRegistry` sees the exact order the column would land in on drop.
     *
     * @param targetIdx   - Effective slot index the dragged column is hovering over.
     * @param sourceIdx   - Original slot index of the dragged column in its panel.
     * @param pd          - Panel drag data for the source panel.
     */
    private rebuildGroupRowsWithPreview;
    /**
     * Resolves which panel the cursor is over, with hysteresis at the seam.
     *
     * Leaving a panel is what triggers a live cross-panel move — a real
     * `moveAndPin`, a store write, and a re-render. A pointer resting on a seam
     * jitters by a pixel or two, and without hysteresis each jitter re-pinned the
     * column and re-rendered the grid, several times a second. The cursor must now
     * clear the current panel's edge by {@link PANEL_SEAM_HYSTERESIS} before a
     * different panel can win, and because the source panel becomes the new panel
     * after a crossing, coming back costs the same margin.
     *
     * @param clientX - Cursor x for this frame.
     * @returns The panel entry the drag should be treated as being in, or
     *   `undefined` when the cursor is over no panel at all.
     */
    private resolveTargetPanel;
    /**
     * Recomputes the drop slot and the live column-shift transforms for one frame.
     *
     * Every exit path routes its CSS through {@link dragStyles}, which writes the
     * `<style>` element only when the generated text actually changed. Because the
     * drop slot changes a handful of times across a gesture while this function
     * runs once per frame, the overwhelming majority of calls now end in a string
     * comparison rather than a stylesheet re-parse and a grid-wide style
     * recalculation.
     *
     * @param clientX - Cursor x for this frame.
     */
    private onDragMove;
    /**
     * Records the pointer sample. Deliberately does no DOM work — see
     * {@link applyDragFrame}, which the scheduler runs once per painted frame.
     */
    private onGlobalMouseMove;
    /**
     * The column drag's entire per-frame workload.
     *
     * Ordering is deliberate: the cheap state tests come first and return early,
     * the chip transform is written before any geometry is consulted, and every
     * geometry read comes from a cache populated at drag start or at an explicit
     * invalidation point — so nothing in this function can force a synchronous
     * layout.
     *
     * @param clientX - Newest cursor x.
     * @param clientY - Newest cursor y.
     */
    private applyDragFrame;
    private onGlobalMouseUp;
    private cleanupDrag;
    private startResize;
    /**
     * Returns `true` when `colId` (at its new position `newIdx` in the visible
     * columns array) is no longer adjacent to any sibling leaf from its parent
     * group — meaning it has been dragged outside the group's contiguous span.
     *
     * @param colId  - The moved leaf column.
     * @param newIdx - Its new index in `cols`.
     * @param cols   - Current flat visible-column array (after the move).
     */
    private isLeafOutsideGroup;
    /** Resolves the owning `.pg-grid` element from any live header row, or `null`. */
    private getGridEl;
    /**
     * Starts an inline rename of a column: replaces the header label with a text
     * input, committing on Enter/blur and cancelling on Escape. Committing calls
     * {@link ColumnModel.setColumnHeader}, which rebuilds the header with the new
     * text. A no-op when the header cell can't be found.
     */
    private startHeaderRename;
    /**
     * Measures the pixel width needed to show a column's header plus every
     * currently-rendered cell without truncation, clamped to the column's
     * min/max. Only virtualized (on-screen) rows are measured, so the cost scales
     * with the viewport, not the dataset. Uses one reused off-screen `<span>` so
     * cell fonts/metrics match the grid.
     */
    private measureColumnContentWidth;
    /**
     * Auto-sizes the given columns to their content width. Measures each, then
     * commits all widths in a single style flush + single render (via the batch
     * setters), so "Auto Size All" stays cheap. A no-op if the grid DOM or the
     * columns cannot be resolved.
     */
    private autoSizeColumns;
    /**
     * Distributes the center viewport width across the visible unpinned columns
     * so they exactly fill the grid with no horizontal scroll (proportional to
     * current widths, clamped to each column's min/max). Pinned columns keep
     * their widths. A no-op when the center viewport can't be measured.
     */
    private fitColumnsToGrid;
    /**
     * Resets a column's width to its original definition. Clears the user-fixed
     * override in the style manager (so a `flex` column resumes flexing) and
     * restores the model's width, which re-renders via `COLUMNS_STATE_CHANGED`.
     */
    private resetColumnWidth;
    private onAction;
}
//# sourceMappingURL=header-renderer.d.ts.map