import type { TableDeps } from '../../table/baseTable';
import InlineStartOverlayTable from '../../table/regions/inlineStartTable';
import { Overlay, type OverlayDeps } from './_base';
/**
 * @class InlineStartOverlay
 */
export declare class InlineStartOverlay extends Overlay {
    #private;
    /**
     */
    constructor(deps: OverlayDeps);
    /**
     * Factory method to create a subclass of `Table` that is relevant to this overlay.
     *
     * @see Table#constructor
     * @param {...*} args Parameters that will be forwarded to the `Table` constructor.
     * @returns {InlineStartOverlayTable}
     */
    createTable(deps: TableDeps): InlineStartOverlayTable;
    /**
     * Checks if overlay should be fully rendered.
     *
     * @returns {boolean}
     */
    shouldBeRendered(): boolean;
    /**
     * Updates the left overlay position.
     *
     * @returns {boolean}
     */
    resetFixedPosition(): boolean;
    /**
     * Sets the main overlay's horizontal scroll position.
     *
     * @param {number} pos The scroll position.
     * @returns {boolean}
     */
    setScrollPosition(pos: number): boolean;
    /**
     * Triggers onScroll hook callback.
     */
    onScroll(): void;
    /**
     * Calculates total sum cells width. Walks the columns live instead of reading the column-width
     * prefix-sum cache: stretched widths (`stretchH`) are derived from the workspace width, which in
     * turn depends on this sum — the live read resolves that cycle fresh on every call, while a
     * cached read would freeze pre-stretch widths (nothing invalidates the cache when stretching
     * recomputes). Column counts stay far below row counts, so this walk is not a scroll hotspot.
     *
     * @param {number} from Column index which calculates started from.
     * @param {number} to Column index where calculation is finished.
     * @returns {number} Width sum.
     */
    sumCellSizes(from: number, to: number): number;
    /**
     * Adjust overlay root element, children and master table element sizes (width, height).
     */
    adjustElementsSize(): void;
    /**
     * Adjust overlay root element size (width and height).
     */
    adjustRootElementSize(): void;
    /**
     * Adjust overlay root childs size.
     */
    adjustRootChildrenSize(): void;
    /**
     * Adjust the overlay dimensions and position.
     */
    applyToDOM(): void;
    /**
     * Synchronize calculated top position to an element.
     */
    syncOverlayOffset(): void;
    /**
     * Scrolls horizontally to a column at the left edge of the viewport.
     *
     * @param {number} sourceCol  Column index which you want to scroll to.
     * @param {boolean} [beyondRendered]  If `true`, scrolls according to the right
     *                                    edge (left edge is by default).
     * @returns {boolean}
     */
    scrollTo(sourceCol: number, beyondRendered: boolean): boolean;
    /**
     * Gets table parent left position.
     *
     * @returns {number}
     */
    getTableParentOffset(): number;
    /**
     * Gets the main overlay's horizontal scroll position.
     *
     * @returns {number} Main table's horizontal scroll position.
     */
    getScrollPosition(): number;
    /**
     * Gets the main overlay's horizontal overlay offset.
     *
     * @returns {number} Main table's horizontal overlay offset.
     */
    getOverlayOffset(): number;
    /**
     * Pre-applies the `innerBorderInlineStart` class before the cell render (single-pass gated
     * path), so the post-render `resetFixedPosition` toggle is a no-op and the nested re-draw is
     * skipped. Element mode only — see `TopOverlay#prepareHeaderBorders`.
     */
    prepareHeaderBorders(): void;
    /**
     * Adds css classes to hide the header border's header (cell-selection border hiding issue).
     *
     * @param {number} position Header X position if trimming container is window or scroll top if not.
     * @returns {boolean}
     */
    adjustHeaderBordersPosition(position: number): boolean;
}