import * as _angular_core from '@angular/core';
import { VirtualItem } from 'forty-cdk/virtualization';

/**
 * Opt-in row-virtualization companion for `[forTable]` in `<div role>` grid mode. Place it on the
 * same element as `[forTable]`; it builds the windowing core from the table's `[rowCount]` and
 * exposes the visible window for the consumer to render with their own `@for` + position transform.
 *
 * Tree-shakeable: `ForTable` never imports the virtualization core — only consumers that import
 * `ForTableVirtualized` bundle `@tanstack/virtual-core`.
 *
 * The focused row is kept mounted even when scrolled out of the window so the roving-focused
 * `gridcell` is never unmounted. SSR-safe: off-browser the window is empty and
 * `totalSize` is the estimate-based total.
 *
 * Also drives cross-window keyboard navigation: when an Arrow / Page / Ctrl+Home / Ctrl+End grid
 * action resolves a row outside the rendered window, it scrolls that row into view and moves roving
 * focus onto the target cell once it mounts (preserving the current column). `ForTable` stays
 * unaware of virtualization — it delegates the row-crossing move through the table context.
 */
declare class ForTableVirtualized {
    #private;
    /** Estimated row size in px along the scroll axis (the fixed-size fast path). Read for the size estimate. */
    readonly estimateRowSize: _angular_core.InputSignalWithTransform<number, unknown>;
    /**
     * Scroll container. Defaults to the table root element (the scroll container in `<div>` grid
     * mode). Bind it explicitly when the scroll container is an **ancestor** of the table — e.g. an
     * app-shell viewport that scrolls projected content — since the table cannot inject an ancestor
     * it does not own. A design-system wrapper can re-expose or rename this input through
     * `hostDirectives` input aliasing (`inputs: ['scrollElement: scrollContainer']`) with no bridging
     * effect required.
     */
    readonly scrollElement: _angular_core.InputSignal<HTMLElement | null>;
    constructor();
    /**
     * The rows in the visible window plus overscan, augmented to always include the focused row and
     * the row being reordered even when they are scrolled out of view (so the roving-focused cell
     * stays mounted, and a pointer reorder drag never unmounts the lifted row). Render these with
     * `@for (vrow of v.virtualRows(); track vrow.index)` and position each row absolutely with
     * `transform: translateY(vrow.start + 'px')`. Bind each row's `[virtualIndex]="vrow.index"`.
     */
    readonly virtualRows: _angular_core.Signal<readonly VirtualItem[]>;
    /** Total scroll size of all rows in px. Bind to the body container's height to size the scroll range. */
    readonly totalSize: _angular_core.Signal<number>;
    /**
     * The rendered window as the inclusive-exclusive `[firstIndex, lastIndex + 1)` index range,
     * sourced from the underlying virtualizer (the true window) — not from {@link virtualRows},
     * which is augmented with the focused / reordering rows. So a row retained out of the window
     * never widens this range. Plugs straight into `injectInfiniteScroll({ range, count, onLoadMore })`.
     */
    readonly range: _angular_core.Signal<readonly [number, number]>;
    /**
     * Scroll the container so the row at `index` is in view. Cross-window keyboard
     * navigation calls this internally; consumers may also call it to scroll
     * programmatically.
     */
    scrollToRow(index: number, options?: {
        align?: 'start' | 'center' | 'end' | 'auto';
    }): void;
    /**
     * Record the measured size of a rendered row element (dynamic / measured row heights).
     * Passing `null` sweeps evicted rows recycled out of the window from the measurement cache.
     */
    measureRow(element: HTMLElement | null): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTableVirtualized, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTableVirtualized, "[forTableVirtualized]", ["forTableVirtualized"], { "estimateRowSize": { "alias": "estimateRowSize"; "required": false; "isSignal": true; }; "scrollElement": { "alias": "scrollElement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { ForTableVirtualized };