import type { RowHeadersRenderer } from './rowHeaders';
import type { ColumnHeaderRowsRenderer } from './columnHeaderRows';
import type { ColumnHeadersRenderer } from './columnHeaders';
import type { ColGroupRenderer } from './colGroup';
import type { RowsRenderer } from './rows';
import type { CellsRenderer } from './cells';
import type RowFilter from '../filter/row';
import type ColumnFilter from '../filter/column';
import type RowUtils from '../utils/row';
import type ColumnUtils from '../utils/column';
import type { StylesHandler } from '../types';
/**
 * TableRenderer class collects all renderers and properties necessary for table creation. It's
 * responsible for adjusting and rendering each renderer.
 *
 * Below is a diagram of the renderers together with an indication of what they are responisble for.
 *   <table>
 *     <colgroup>  \ (root node)
 *       <col>      \
 *       <col>       \___ ColGroupRenderer
 *       <col>       /
 *       <col>      /
 *     </colgroup> /
 *     <thead>     \ (root node)
 *       <tr>       --- ColumnHeaderRowsRenderer
 *         <th>      \
 *         <th>       \__ ColumnHeadersRenderer
 *         <th>       /
 *         <th>      /
 *       </tr>      /
 *     </thead>    /
 *     <tbody>   ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\ (root node)
 *       <tr>   (root node)          \
 *         <th>  --- RowHeadersRenderer
 *         <td>  \                     \
 *         <td>   -- CellsRenderer      \
 *         <td>  /                       \
 *       </tr>                            \
 *       <tr>   (root node)                \
 *         <th>  --- RowHeadersRenderer     \
 *         <td>  \                           \___ RowsRenderer
 *         <td>   -- CellsRenderer           /
 *         <td>  /                          /
 *       </tr>                             /
 *       <tr>   (root node)               /
 *         <th>  --- RowHeadersRenderer  /
 *         <td>  \                      /
 *         <td>   -- CellsRenderer     /
 *         <td>  /                    /
 *       </tr>                       /
 *     </tbody>  ___________________/
 *   </table>.
 *
 * @class {RowsRenderer}
 */
export declare class TableRenderer {
    /**
     * Table element which will be used to render the children element.
     *
     * @type {HTMLTableElement}
     */
    rootNode: HTMLTableElement;
    /**
     * Document owner of the root node.
     *
     * @type {HTMLDocument}
     */
    rootDocument: Document;
    /**
     * Renderer class responsible for rendering row headers.
     *
     * @type {RowHeadersRenderer}
     */
    rowHeaders: RowHeadersRenderer | null;
    /**
     * Renderer class responsible for rendering column header rows (TR elements in THEAD).
     *
     * @type {ColumnHeaderRowsRenderer}
     */
    columnHeaderRows: ColumnHeaderRowsRenderer | null;
    /**
     * Renderer class responsible for rendering column headers (TH elements in TR).
     *
     * @type {ColumnHeadersRenderer}
     */
    columnHeaders: ColumnHeadersRenderer | null;
    /**
     * Renderer class responsible for rendering col in colgroup.
     *
     * @type {ColGroupRenderer}
     */
    colGroup: ColGroupRenderer | null;
    /**
     * Renderer class responsible for rendering rows in tbody.
     *
     * @type {RowsRenderer}
     */
    rows: RowsRenderer | null;
    /**
     * Renderer class responsible for rendering cells.
     *
     * @type {CellsRenderer}
     */
    cells: CellsRenderer | null;
    /**
     * Row filter which contains all necessary information about row index transformation.
     *
     * @type {RowFilter}
     */
    rowFilter: RowFilter | null;
    /**
     * Column filter which contains all necessary information about column index transformation.
     *
     * @type {ColumnFilter}
     */
    columnFilter: ColumnFilter | null;
    /**
     * Row utils class which contains all necessary information about sizes of the rows.
     *
     * @type {RowUtils}
     */
    rowUtils: RowUtils | null;
    /**
     * Column utils class which contains all necessary information about sizes of the columns.
     *
     * @type {ColumnUtils}
     */
    columnUtils: ColumnUtils | null;
    /**
     * Indicates how much rows should be rendered to fill whole table viewport.
     *
     * @type {number}
     */
    rowsToRender: number;
    /**
     * Indicates how much columns should be rendered to fill whole table viewport.
     *
     * @type {number}
     */
    columnsToRender: number;
    /**
     * An array of functions to be used as a content factory to row headers.
     *
     * @type {Function[]}
     */
    rowHeaderFunctions: Function[];
    /**
     * Count of the function used to render row headers.
     *
     * @type {number}
     */
    rowHeadersCount: number;
    /**
     * An array of functions to be used as a content factory to column headers.
     *
     * @type {Function[]}
     */
    columnHeaderFunctions: Function[];
    /**
     * Count of the function used to render column headers.
     *
     * @type {number}
     */
    columnHeadersCount: number;
    /**
     * Cell renderer used to render cells content.
     *
     * @type {Function}
     */
    cellRenderer: Function;
    /**
     * Holds the name of the currently active overlay.
     *
     * @type {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'}
     */
    activeOverlayName: string;
    /**
     * Styles handler instance.
     */
    stylesHandler: StylesHandler;
    /**
     * Creates a new TableRenderer instance.
     *
     * @param {HTMLTableElement} rootNode The HTML table element to use as the root node for rendering.
     * @param {object} options The configuration options.
     * @param {Function} [options.cellRenderer] The cell renderer function.
     * @param {StylesHandler} [options.stylesHandler] The styles handler instance.
     */
    constructor(rootNode: HTMLTableElement, { cellRenderer, stylesHandler }?: {
        cellRenderer?: Function;
        stylesHandler?: StylesHandler;
    });
    /**
     * Sets the overlay that is currently rendered. If `null` is provided, the master overlay is set.
     *
     * @param {'inline_start'|'top'|'top_inline_start_corner'|'bottom'|'bottom_inline_start_corner'|'master'} overlayName The overlay name.
     */
    setActiveOverlayName(overlayName: string): void;
    /**
     * Set row and column util classes.
     *
     * @param {RowUtils} rowUtils RowUtils instance which provides useful methods related to row sizes.
     * @param {ColumnUtils} columnUtils ColumnUtils instance which provides useful methods related to row sizes.
     */
    setAxisUtils(rowUtils: RowUtils, columnUtils: ColumnUtils): void;
    /**
     * Sets viewport size of the table.
     *
     * @param {number} rowsCount An amount of rows to render.
     * @param {number} columnsCount An amount of columns to render.
     */
    setViewportSize(rowsCount: number, columnsCount: number): void;
    /**
     * Sets row and column filter instances.
     *
     * @param {RowFilter} rowFilter Row filter instance which contains all necessary information about row index transformation.
     * @param {ColumnFilter} columnFilter Column filter instance which contains all necessary information about row
     * index transformation.
     */
    setFilters(rowFilter: RowFilter, columnFilter: ColumnFilter): void;
    /**
     * Sets row and column header functions.
     *
     * @param {Function[]} rowHeaders Row header functions. Factories for creating content for row headers.
     * @param {Function[]} columnHeaders Column header functions. Factories for creating content for column headers.
     */
    setHeaderContentRenderers(rowHeaders: Function[], columnHeaders: Function[]): void;
    /**
     * Sets table renderers.
     *
     * @param {renderers} renderers The renderer units.
     * @param {RowHeadersRenderer} renderers.rowHeaders Row headers renderer.
     * @param {ColumnHeaderRowsRenderer} renderers.columnHeaderRows Column header rows renderer.
     * @param {ColumnHeadersRenderer} renderers.columnHeaders Column headers renderer.
     * @param {ColGroupRenderer} renderers.colGroup Col group renderer.
     * @param {RowsRenderer} renderers.rows Rows renderer.
     * @param {CellsRenderer} renderers.cells Cells renderer.
     */
    setRenderers({ rowHeaders, columnHeaderRows, columnHeaders, colGroup, rows, cells }: {
        rowHeaders: RowHeadersRenderer;
        columnHeaderRows: ColumnHeaderRowsRenderer;
        columnHeaders: ColumnHeadersRenderer;
        colGroup: ColGroupRenderer;
        rows: RowsRenderer;
        cells: CellsRenderer;
    }): void;
    /**
     * Transforms visual/rendered row index to source index.
     *
     * @param {number} rowIndex Rendered index.
     * @returns {number}
     */
    renderedRowToSource(rowIndex: number): number;
    /**
     * Transforms visual/rendered column index to source index.
     *
     * @param {number} columnIndex Rendered index.
     * @returns {number}
     */
    renderedColumnToSource(columnIndex: number): number;
    /**
     * Returns `true` if the accessibility-related ARIA tags should be added to the table, `false` otherwise.
     *
     * @returns {boolean}
     */
    isAriaEnabled(): boolean;
    /**
     * Renders the table.
     */
    render(): void;
}