/** A column's identity and its horizontal offset within its own panel. */
export interface ColumnPosition {
    colId: string;
    /** Distance (px) from the panel's left content edge to this column's left edge. */
    x: number;
}
/**
 * Which change produced the new column layout, so the animator can pick a
 * duration and decide whether a column that vanished deserves an exit.
 *
 * - `'visibility'` — a column was hidden or shown (header context menu, column
 *   chooser, or dragged out of the grid). Survivors slide; a newly-shown column
 *   fades in where it lands.
 * - `'reorder'` — columns were permuted with the same membership (a programmatic
 *   `moveColumn`, or a drop that committed). Pure slide.
 */
export type ColumnAnimationType = 'visibility' | 'reorder';
/**
 * FLIP-based column animation engine — the horizontal counterpart to
 * `RowAnimator`.
 *
 * ### Why this exists
 * Hiding a column is a *structural* layout change: the renderer tears the
 * header down and rebuilds every row, so the surviving columns jump to their
 * new offsets in a single frame. Dragging a column, by contrast, has always
 * animated (`.pg-grid--col-dragging` shifts neighbours via `--pg-drag-x` on a
 * 180 ms transition). This class gives the structural path the same motion, so
 * a column disappearing from the context menu reads exactly like one being
 * dragged out of the way.
 *
 * ### Why a stylesheet, not inline styles
 * A column's position is expressed once per `colId` and applies to its header
 * cell, its filter cell, and every rendered body cell in that column — hundreds
 * of elements. `RowAnimator` writes inline styles because a row *is* a single
 * element per panel; here the equivalent would be a write per cell. Instead the
 * animator emits one CSS rule per column into a single `<style>` tag (the same
 * technique `ColumnStyleManager` uses for widths and `HeaderRenderer` uses for
 * live-drag transforms), so the cost is O(visible columns) regardless of how
 * many rows are on screen.
 *
 * ### Ordering
 * ```
 * capture(currentColumns)   // BEFORE the columns store changes
 * …store mutation + full header/body rebuild…
 * animate(newColumns)       // AFTER the renderer has committed the new layout
 * ```
 *
 * ### Virtualization
 * Offsets are computed from the column model and `ColumnStyleManager`'s resolved
 * widths, never from `getBoundingClientRect` — so the pass forces no layout, and
 * a center column outside the current virtual window is simply absent from the
 * DOM and silently skipped by the browser when its rule matches nothing.
 */
export declare class ColumnAnimator {
    private styleEl;
    /** The grid wrapper the `.pg-grid--col-animating*` classes are toggled on. */
    private rootEl;
    /** Selector prefix scoping every rule to this grid instance — see `ColumnStyleManager.setScopeId` for why an unscoped `[data-col-id]` is unsafe under Master/Detail. */
    private scopePrefix;
    private snapshot;
    private animationType;
    /** `true` between the invert write and the frame that starts the transitions. */
    private playPending;
    private cleanupTimer;
    private playFrame;
    mount(): void;
    /** Scopes every generated rule to `[data-photon-grid-id="id"]`. Call once, right after the wrapper element receives that attribute. */
    setScopeId(id: string): void;
    /** Wires the element that carries the animation classes. Call alongside {@link setScopeId}. */
    setRoot(el: HTMLElement | null): void;
    /**
     * Snapshot the on-screen column layout **before** the change that will move
     * it. Discards any snapshot that was never consumed, so a burst of rapid
     * changes always animates from the most recent visual state rather than a
     * stale one.
     *
     * @param columns - Visible columns with their current per-panel offsets.
     * @param type - Controls the entrance style for newly-shown columns.
     */
    capture(columns: readonly ColumnPosition[], type?: ColumnAnimationType): void;
    /** Whether a `capture()` is waiting to be consumed by the next `animate()`. */
    hasPending(): boolean;
    /** Drops a pending snapshot without animating — used when the change turns out not to be animatable. */
    cancel(): void;
    /**
     * Play the FLIP, after the DOM has been rebuilt with the new column layout.
     *
     * @param columns - Visible columns with their new per-panel offsets.
     */
    animate(columns: readonly ColumnPosition[]): void;
    /** `true` while columns are mid-transition — lets a caller skip capturing a new snapshot mid-flight. */
    isAnimating(): boolean;
    destroy(): void;
    /**
     * Ends the animation immediately: transitions off, offsets cleared,
     * `will-change` released. Idempotent, and safe to call at any phase.
     */
    private finish;
    private setClasses;
}
/**
 * Builds per-panel column offsets for {@link ColumnAnimator.capture} /
 * {@link ColumnAnimator.animate}.
 *
 * Offsets are cumulative widths within each panel, taken from the resolved
 * width map rather than the DOM — no layout is forced, and columns currently
 * outside the center panel's virtual window are still positioned correctly
 * (their rules simply match no elements until they scroll in).
 *
 * @param panels - Visible column ids per panel, in display order.
 * @param widthOf - Resolved width for a column id, e.g. `ColumnStyleManager.getWidth`.
 */
export declare function computeColumnPositions(panels: {
    left: readonly string[];
    center: readonly string[];
    right: readonly string[];
}, widthOf: (colId: string) => number): ColumnPosition[];
//# sourceMappingURL=column-animator.d.ts.map