import { EventEmitter, h } from '../../stencil-public-runtime';
import { SceneTreeController } from '../scene-tree/lib/controller';
import { Row } from '../scene-tree/lib/row';
import { RowDataProvider } from '../scene-tree/types';
import { DomScrollToOptions } from './lib/dom';
export declare class SceneTreeTableLayout {
    /**
     * A reference to the scene tree to perform operations for interactions. Such
     * as expansion, visibility and selection.
     */
    tree?: HTMLVertexSceneTreeElement;
    /**
     * @internal
     */
    controller?: SceneTreeController;
    /**
     * @internal
     */
    rows: Row[];
    /**
     * @internal
     */
    totalRows: number;
    /**
     * @internal
     */
    rowHeight: number;
    /**
     * The number of offscreen rows above and below the viewport to render. Having
     * a higher number reduces the chance of the browser not displaying a row
     * while scrolling.
     *
     * This prop will be automatically populated based on the `overScanCount` prop
     * specified in the parent `<vertex-scene-tree />` element.
     */
    overScanCount: number;
    /**
     * A callback that is invoked immediately before a row is about to be rendered.
     * This callback can return additional data that can be bound to in a
     * template.
     *
     * This prop will be automatically populated based on the `rowData` prop
     * specified in the parent `<vertex-scene-tree />` element.
     *
     * @example
     *
     * ```html
     * <script>
     *   const table = document.querySelector('vertex-scene-tree-table');
     *   table.rowData = (row) => {
     *     return { func: () => console.log('row', row.node.name) };
     *   }
     * </script>
     *
     * <vertex-scene-tree>
     *  <vertex-scene-tree-table>
     *    <vertex-scene-tree-table-column>
     *      <template>
     *        <button event:click="{{row.data.func}}">Hi</button>
     *      </template>
     *    </vertex-scene-tree-table-column>
     *  </vertex-scene-tree-table>
     * </vertex-scene-tree>
     * ```
     */
    rowData?: RowDataProvider;
    /**
     * @internal
     */
    layoutOffset: number;
    /**
     * @internal
     */
    scrollOffset: number;
    /**
     * @internal
     */
    layoutHeight?: number;
    /**
     * @internal
     */
    layoutWidth?: number;
    /**
     * @internal
     */
    viewportStartIndex: number;
    /**
     * @internal
     */
    viewportEndIndex: number;
    /**
     * @internal
     */
    layoutRendered: EventEmitter<void>;
    /**
     * An event that is emitted when the columns of this `<vertex-scene-tree-table-layout>`
     * are resized with an array containing the widths of the columns in pixels.
     */
    columnsResized: EventEmitter<number[]>;
    private hostEl;
    private columnGridLayout;
    private columnGridFixedLayout;
    private isComputingCellHeight;
    private lastDividerPointerPosition?;
    private resizingColumnIndex?;
    private isScrolling;
    private scrollTimer;
    /**
     * This stores internal state that you want to preserve across live-reloads,
     * but shouldn't trigger a refresh if the data changes. Marking this with
     * @State to allow to preserve state across live-reloads.
     */
    private stateMap;
    private lastStartIndex;
    private resizeObserver?;
    private headerResizeObserver?;
    private tableElement?;
    private headerElement?;
    private columnElements;
    private cellHoverController;
    componentWillLoad(): void;
    componentDidLoad(): Promise<void>;
    componentWillRender(): Promise<void>;
    componentDidRender(): void;
    componentDidUpdate(): Promise<void>;
    disconnectedCallback(): void;
    protected handleViewportRowsPropsChanged(): Promise<void>;
    /**
     * Scrolls the table to the provided top value.
     *
     * @param top The position to scroll to.
     * @param options A set of options to configure the scrolling behavior.
     */
    scrollToPosition(top: number, options: Pick<DomScrollToOptions, 'behavior'>): Promise<void>;
    /**
     * Attempts to compute the height of templated cells. Used for internals
     * or testing.
     *
     * @internal
     * @ignore
     */
    attemptComputeCellHeight(): Promise<void>;
    render(): h.JSX.IntrinsicElements;
    private computeViewportRows;
    private computeAndUpdateViewportRows;
    private layoutColumns;
    private updateCell;
    private updateLayoutPosition;
    private recomputeColumnWidths;
    private recomputeColumnPercentages;
    private computeInitialColumnWidths;
    private updateColumnElements;
    private createPools;
    private recreateColumnPools;
    private iterateColumns;
    private ensureDividerTemplateDefined;
    private createHeaderInstance;
    private createDividerInstance;
    private createColumnCellInstance;
    private computeCellHeight;
    private computeHeaderHeight;
    private computeColumnGridLayout;
    private bindHeaderData;
    private rebindHeaderData;
    private addDividerDragListeners;
    private removeDividerDragListeners;
    private createDividerPointerDownHandler;
    private handleDividerPointerMove;
    private handleDividerPointerUp;
    private isValidResize;
    private handleScrollChanged;
    private getViewportRows;
    private populateRowData;
    private getLayoutHeight;
    private getLayoutWidth;
    private clearLayoutHeight;
    private clearLayoutWidth;
}
