@mikestools/usetable 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,504 @@
+import { Ref } from 'vue';
+
+/** Cell change record for dirty tracking. @public */
+export declare interface CellChange {
+    row: number;
+    column: number;
+    oldValue: unknown;
+    newValue: unknown;
+}
+
+/** Configuration for a table cell with content and attributes. @public */
+export declare interface CellConfig {
+    value: unknown;
+    attributes?: ElementAttributes;
+    columnSpan?: number;
+    rowSpan?: number;
+}
+
+/** Cell position for focus/navigation. @public */
+export declare interface CellPosition {
+    row: number;
+    column: number;
+}
+
+export declare type CellValidator = (value: unknown) => boolean | string;
+
+/** Configuration for a table column. @public */
+export declare interface ColumnConfig {
+    header: string | CellConfig;
+    defaultValue?: unknown;
+    defaultAttributes?: ElementAttributes;
+}
+
+/** Column definition for type parsing/formatting. @public */
+export declare interface ColumnDefinition {
+    type: 'string' | 'number' | 'date' | 'boolean';
+    parser?: (value: unknown) => unknown;
+    formatter?: (value: unknown) => string;
+    defaultValue?: unknown;
+    nullable?: boolean;
+}
+
+/** Computed column configuration. @public */
+export declare interface ComputedColumnConfig {
+    computeFunction: (row: unknown[]) => unknown;
+    label: string;
+    index?: number;
+}
+
+/** Editable configuration. @public */
+export declare interface EditableConfig {
+    cells?: boolean;
+    headers?: boolean;
+    footers?: boolean;
+    editableColumns?: number[];
+    editableRows?: number[];
+    validator?: (value: string, row: number, col: number) => boolean | string;
+    parser?: (value: string, row: number, col: number) => unknown;
+    onEdit?: (value: unknown, row: number, col: number) => void;
+}
+
+/**
+ * Comprehensive HTML element attributes for table elements.
+ * @public
+ */
+export declare interface ElementAttributes extends Partial<Omit<HTMLElement, 'style' | 'className' | 'classList' | 'children' | 'childNodes' | 'parentNode' | 'parentElement' | 'attributes' | 'tagName' | 'namespaceURI' | 'shadowRoot' | 'assignedSlot' | 'offsetParent' | 'offsetTop' | 'offsetLeft' | 'offsetWidth' | 'offsetHeight' | 'clientTop' | 'clientLeft' | 'clientWidth' | 'clientHeight' | 'scrollTop' | 'scrollLeft' | 'scrollWidth' | 'scrollHeight' | 'innerHTML' | 'outerHTML' | 'innerText' | 'outerText' | 'textContent' | 'addEventListener' | 'removeEventListener' | 'dispatchEvent' | 'getAttribute' | 'setAttribute' | 'removeAttribute' | 'hasAttribute' | 'appendChild' | 'removeChild' | 'replaceChild' | 'insertBefore' | 'querySelector' | 'querySelectorAll' | 'getElementsByTagName' | 'getElementsByClassName' | 'getElementById' | 'animate' | 'getAnimations' | 'attachShadow' | 'closest' | 'matches' | 'webkitMatchesSelector' | 'getBoundingClientRect' | 'getClientRects' | 'scrollIntoView' | 'scroll' | 'scrollBy' | 'scrollTo' | 'focus' | 'blur' | 'click'>>, Partial<GlobalEventHandlers>, Partial<ARIAMixin> {
+    class?: string | string[] | Record<string, boolean>;
+    style?: string | Partial<CSSStyleDeclaration> | Record<string, string | number>;
+    dataset?: Record<string, string>;
+    [key: `data-${string}`]: string;
+    [key: `aria-${string}`]: string;
+    [key: string]: unknown;
+}
+
+/** Filter state for tracking row filtering. @public */
+export declare interface FilterState {
+    readonly isFiltered: Readonly<Ref<boolean>>;
+    readonly filteredRowCount: Readonly<Ref<number>>;
+    readonly filteredIndices: Readonly<Ref<readonly number[]>>;
+}
+
+export declare type FullValidator = (value: unknown, row: number, col: number) => string | null;
+
+export declare function isCellConfig(value: unknown): value is CellConfig;
+
+export declare function isValidationError(value: unknown): value is ValidationError;
+
+export declare function isValidationErrorArray(value: unknown): value is ValidationError[];
+
+export declare function isValidationResult(value: unknown): value is ValidationResult;
+
+/** Pagination configuration. @public */
+export declare interface PaginationConfig {
+    pageSize: number;
+    currentPage?: number;
+}
+
+/** Pagination state. @public */
+export declare interface PaginationState {
+    totalPages: Readonly<Ref<number>>;
+    currentPage: Ref<number>;
+    pageSize: Ref<number>;
+    visibleRows: Ref<number[]>;
+}
+
+/** Reactive wrapper for table cells. @public */
+export declare interface ReactiveCellCollection {
+    readonly cells: Readonly<Ref<readonly HTMLTableCellElement[]>>;
+    readonly cellCount: Readonly<Ref<number>>;
+}
+
+/** Reactive wrapper for table rows. @public */
+export declare interface ReactiveRowCollection {
+    readonly rows: Readonly<Ref<readonly HTMLTableRowElement[]>>;
+    readonly rowCount: Readonly<Ref<number>>;
+}
+
+/** Reactive wrapper for tbody elements. @public */
+export declare interface ReactiveTBodyCollection {
+    readonly tBodies: Readonly<Ref<readonly HTMLTableSectionElement[]>>;
+    readonly tBodyCount: Readonly<Ref<number>>;
+}
+
+export declare type RowValidator = (rowData: unknown[]) => boolean | string;
+
+/** Search options. @public */
+export declare interface SearchOptions {
+    caseSensitive?: boolean;
+}
+
+/** Search result. @public */
+export declare interface SearchResult {
+    row: number;
+    column: number;
+    value: unknown;
+}
+
+/** Sort state for tracking column sorting. @public */
+export declare interface SortState {
+    readonly columnIndex: Readonly<Ref<number | null>>;
+    readonly ascending: Readonly<Ref<boolean>>;
+    readonly descending: Readonly<Ref<boolean>>;
+}
+
+/** Table cell composable. @public */
+export declare interface TableCell {
+    readonly element: Readonly<Ref<HTMLTableCellElement>>;
+    readonly cellIndex: Readonly<Ref<number>>;
+    readonly columnSpan: Ref<number>;
+    readonly rowSpan: Ref<number>;
+    readonly headers: Ref<string>;
+    readonly abbr: Ref<string>;
+    readonly scope: Ref<string>;
+}
+
+/** Table row composable. @public */
+export declare interface TableRow extends ReactiveCellCollection {
+    readonly element: Readonly<Ref<HTMLTableRowElement>>;
+    readonly rowIndex: Readonly<Ref<number>>;
+    readonly sectionRowIndex: Readonly<Ref<number>>;
+    insertCell(index?: number): HTMLTableCellElement;
+    deleteCell(index: number): void;
+    getCell(index: number): TableCell | undefined;
+}
+
+/** Table section composable. @public */
+export declare interface TableSection extends ReactiveRowCollection {
+    readonly element: Readonly<Ref<HTMLTableSectionElement>>;
+    insertRow(index?: number): HTMLTableRowElement;
+    deleteRow(index: number): void;
+    getRow(index: number): TableRow | undefined;
+}
+
+/**
+ * A comprehensive Vue composable for direct HTML table DOM manipulation.
+ * DOM is the source of truth - data and headers are computed from DOM state.
+ * @public
+ */
+export declare function useTable(element: Ref<HTMLTableElement>): UseTableReturn;
+
+/** Main table composable return type. @public */
+export declare interface UseTableReturn extends ReactiveRowCollection, ReactiveTBodyCollection {
+    readonly element: Readonly<Ref<HTMLTableElement>>;
+    readonly caption: Ref<HTMLTableCaptionElement | null>;
+    readonly tHead: Ref<HTMLTableSectionElement | null>;
+    readonly tFoot: Ref<HTMLTableSectionElement | null>;
+    readonly data: Ref<unknown[][]>;
+    readonly headers: Ref<string[]>;
+    readonly columnCount: Readonly<Ref<number>>;
+    createCaption(): HTMLTableCaptionElement;
+    deleteCaption(): void;
+    createTHead(): HTMLTableSectionElement;
+    deleteTHead(): void;
+    createTFoot(): HTMLTableSectionElement;
+    deleteTFoot(): void;
+    createTBody(): HTMLTableSectionElement;
+    insertRow(index?: number): HTMLTableRowElement;
+    deleteRow(index: number): void;
+    getTHead(): TableSection | undefined;
+    getTFoot(): TableSection | undefined;
+    getTBody(index: number): TableSection | undefined;
+    getRow(index: number): TableRow | undefined;
+    addRow(rowData: readonly unknown[], index?: number): HTMLTableRowElement;
+    removeRow(index: number): void;
+    addColumn(headerText?: string, defaultValue?: unknown, index?: number): void;
+    removeColumn(index: number): void;
+    setCell(rowIndex: number, columnIndex: number, value: unknown): void;
+    getCell(rowIndex: number, columnIndex: number): unknown;
+    setCaption(text: string): void;
+    setHeaders(headerTexts: readonly string[]): void;
+    setFooter(footerData: readonly unknown[]): void;
+    setData(newData: readonly (readonly unknown[])[]): void;
+    clearData(): void;
+    reset(): void;
+    sync(): void;
+    addRowWithAttributes(rowData: readonly (unknown | CellConfig)[], attributes?: ElementAttributes, index?: number): HTMLTableRowElement;
+    addColumnWithAttributes(config: ColumnConfig, index?: number): void;
+    setHeadersWithAttributes(headerConfigs: readonly (string | CellConfig)[]): void;
+    setCellWithAttributes(rowIndex: number, columnIndex: number, value: unknown, attributes?: ElementAttributes): void;
+    getRowData(index: number): unknown[] | undefined;
+    setRowData(index: number, rowData: readonly unknown[]): void;
+    getAllRowData(): unknown[][];
+    getColumnData(index: number): unknown[];
+    setColumnData(index: number, columnData: readonly unknown[]): void;
+    getCellRange(rowStart: number, rowEnd: number, columnStart: number, columnEnd: number): unknown[][];
+    setCellRange(rowStart: number, columnStart: number, rangeData: readonly (readonly unknown[])[]): void;
+    getHeaderData(): string[];
+    getFooterData(): unknown[] | undefined;
+    setFooterCell(columnIndex: number, value: unknown): void;
+    getFooterCell(columnIndex: number): unknown;
+    updateCell(rowIndex: number, columnIndex: number, config: CellConfig): void;
+    updateRow(index: number, rowData: readonly (unknown | CellConfig)[]): void;
+    getCellElement(rowIndex: number, columnIndex: number): HTMLTableCellElement | undefined;
+    getRowElement(index: number): HTMLTableRowElement | undefined;
+    selectRows(indices: readonly number[]): unknown[][];
+    selectColumns(indices: readonly number[]): unknown[][];
+    updateRows(updates: ReadonlyMap<number, readonly (unknown | CellConfig)[]>): void;
+    updateCells(updates: ReadonlyMap<readonly [number, number], unknown | CellConfig>): void;
+    getRowElements(): readonly HTMLTableRowElement[];
+    getRowCellElements(rowIndex: number): readonly HTMLTableCellElement[];
+    setRows(startIndex: number, rows: readonly (readonly (unknown | CellConfig)[])[]): void;
+    validateCell(rowIndex: number, columnIndex: number, validator: CellValidator): true | ValidationError;
+    validateRow(index: number, validator: RowValidator): true | ValidationError[];
+    validateColumn(index: number, validator: CellValidator): true | ValidationError[];
+    validateAll(validator: FullValidator): ValidationResult;
+    sum(columnIndex: number): number;
+    average(columnIndex: number): number;
+    min(columnIndex: number): unknown;
+    max(columnIndex: number): unknown;
+    count(columnIndex: number, predicate?: (value: unknown) => boolean): number;
+    aggregate<T>(columnIndex: number, options: {
+        initial: T;
+        reducer: (accumulator: T, value: unknown, rowIndex: number) => T;
+    }): T;
+    transformColumn(columnIndex: number, transformer: (value: unknown, rowIndex: number) => unknown): void;
+    transformRow(rowIndex: number, transformer: (value: unknown, colIndex: number) => unknown): void;
+    transformCells(transformer: (value: unknown, rowIndex: number, colIndex: number) => unknown): void;
+    exportToCSV(): string;
+    exportToJSON(): string;
+    importFromArray(data: readonly (readonly unknown[])[]): void;
+    importFromCSV(csv: string): void;
+    importFromJSON(json: string): void;
+    search(query: string, options?: SearchOptions): SearchResult[];
+    searchColumn(columnIndex: number, query: string, options?: SearchOptions): SearchResult[];
+    readonly selectedRows: Readonly<Ref<Set<number>>>;
+    readonly selectedCells: Readonly<Ref<Set<string>>>;
+    selectRow(index: number): void;
+    deselectRow(index: number): void;
+    toggleRowSelection(index: number): void;
+    isRowSelected(index: number): boolean;
+    selectCell(rowIndex: number, columnIndex: number): void;
+    clearSelection(): void;
+    enableCellEditing(config?: EditableConfig): void;
+    disableCellEditing(): void;
+    enableHeaderEditing(config?: Omit<EditableConfig, 'cells'>): void;
+    disableHeaderEditing(): void;
+    enableColumnEditing(columnIndex: number, config?: EditableConfig): void;
+    disableColumnEditing(columnIndex: number): void;
+    enableRowEditing(rowIndex: number, config?: EditableConfig): void;
+    disableRowEditing(rowIndex: number): void;
+    enableEditing(): () => void;
+    groupBy(keyFunction: (row: unknown[]) => string | number): Map<string | number, number[]>;
+    addComputedColumn(config: ComputedColumnConfig): number;
+    removeComputedColumn(index: number): void;
+    pagination: PaginationState | null;
+    paginate(config: PaginationConfig): void;
+    nextPage(): void;
+    previousPage(): void;
+    goToPage(page: number): void;
+    virtualScroll: VirtualScrollState | null;
+    enableVirtualScrolling(config: VirtualScrollConfig): void;
+    disableVirtualScrolling(): void;
+    transaction<T>(callback: () => T | Promise<T>): T | Promise<T>;
+    onDataChange(callback: (data: unknown[][]) => void): () => void;
+    readonly sortState: SortState;
+    sortColumnAscending(columnIndex: number): void;
+    sortColumnDescending(columnIndex: number): void;
+    sortColumnAscendingWith(columnIndex: number, comparator: (a: unknown, b: unknown) => number): void;
+    sortColumnDescendingWith(columnIndex: number, comparator: (a: unknown, b: unknown) => number): void;
+    clearColumnSort(): void;
+    getSortedColumnIndex(): number | null;
+    isSortedAscending(): boolean;
+    isSortedDescending(): boolean;
+    isSorted(): boolean;
+    readonly filterState: FilterState;
+    filterRows(predicate: (rowData: unknown[], rowIndex: number) => boolean): void;
+    filterColumn(columnIndex: number, predicate: (value: unknown) => boolean): void;
+    filterColumnByValue(columnIndex: number, value: unknown): void;
+    filterColumnByValues(columnIndex: number, values: readonly unknown[]): void;
+    clearFilters(): void;
+    getFilteredRowIndices(): readonly number[];
+    setRowKeyFunction(keyFunction: (rowData: unknown[], rowIndex: number) => string | number): void;
+    clearRowKeyFunction(): void;
+    hasRowKeyFunction(): boolean;
+    getRowByKey(key: string | number): unknown[] | undefined;
+    getRowIndexByKey(key: string | number): number | undefined;
+    updateRowByKey(key: string | number, rowData: readonly unknown[]): boolean;
+    removeRowByKey(key: string | number): boolean;
+    hasRowWithKey(key: string | number): boolean;
+    getRowKey(rowIndex: number): string | number | undefined;
+    getAllRowKeys(): readonly (string | number)[];
+    setColumnDefinition(columnIndex: number, definition: ColumnDefinition): void;
+    setColumnDefinitions(definitions: readonly (ColumnDefinition | undefined)[]): void;
+    clearColumnDefinition(columnIndex: number): void;
+    clearColumnDefinitions(): void;
+    getColumnDefinition(columnIndex: number): ColumnDefinition | undefined;
+    hasColumnDefinition(columnIndex: number): boolean;
+    getParsedCell(rowIndex: number, columnIndex: number): unknown;
+    getParsedRowData(rowIndex: number): unknown[];
+    getParsedColumnData(columnIndex: number): unknown[];
+    getParsedData(): unknown[][];
+    readonly dirtyState: Readonly<Ref<boolean>>;
+    markClean(): void;
+    markDirty(): void;
+    isDirty(): boolean;
+    hasChanges(): boolean;
+    getChangedCells(): readonly CellChange[];
+    getChangedRowIndices(): readonly number[];
+    getChangedColumnIndices(): readonly number[];
+    undo(): boolean;
+    redo(): boolean;
+    clearHistory(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getUndoStackSize(): number;
+    getRedoStackSize(): number;
+    setHistoryLimit(limit: number): void;
+    getHistoryLimit(): number;
+    selectAllRows(): void;
+    deselectAllRows(): void;
+    selectRowRange(startIndex: number, endIndex: number): void;
+    invertRowSelection(): void;
+    getSelectedRowData(): readonly unknown[][];
+    getSelectedRowIndices(): readonly number[];
+    getSelectedCellIndices(): readonly CellPosition[];
+    readonly focusedCell: Readonly<Ref<CellPosition | null>>;
+    focusCell(rowIndex: number, columnIndex: number): void;
+    clearCellFocus(): void;
+    getFocusedCell(): CellPosition | null;
+    isCellFocused(rowIndex: number, columnIndex: number): boolean;
+    moveFocusUp(): boolean;
+    moveFocusDown(): boolean;
+    moveFocusLeft(): boolean;
+    moveFocusRight(): boolean;
+    moveFocusToFirstCell(): void;
+    moveFocusToLastCell(): void;
+    moveFocusToRowStart(): void;
+    moveFocusToRowEnd(): void;
+    enableKeyboardNavigation(): () => void;
+    readonly visibleColumnCount: Readonly<Ref<number>>;
+    hideColumn(columnIndex: number): void;
+    showColumn(columnIndex: number): void;
+    toggleColumnVisibility(columnIndex: number): void;
+    isColumnVisible(columnIndex: number): boolean;
+    getVisibleColumnIndices(): readonly number[];
+    getHiddenColumnIndices(): readonly number[];
+    moveRow(fromIndex: number, toIndex: number): void;
+    moveRowUp(rowIndex: number): boolean;
+    moveRowDown(rowIndex: number): boolean;
+    moveRowToTop(rowIndex: number): void;
+    moveRowToBottom(rowIndex: number): void;
+    swapRows(indexA: number, indexB: number): void;
+    moveColumn(fromIndex: number, toIndex: number): void;
+    moveColumnLeft(columnIndex: number): boolean;
+    moveColumnRight(columnIndex: number): boolean;
+    moveColumnToStart(columnIndex: number): void;
+    moveColumnToEnd(columnIndex: number): void;
+    swapColumns(indexA: number, indexB: number): void;
+    copySelectedCells(): string;
+    copySelectedRows(): string;
+    copyRow(rowIndex: number): string;
+    copyColumn(columnIndex: number): string;
+    copyCell(rowIndex: number, columnIndex: number): string;
+    copyCellRange(rowStart: number, columnStart: number, rowEnd: number, columnEnd: number): string;
+    pasteAtCell(rowIndex: number, columnIndex: number, data: string): void;
+    readonly expandedRows: Readonly<Ref<ReadonlySet<number>>>;
+    readonly pinnedTopRows: Readonly<Ref<readonly number[]>>;
+    readonly pinnedBottomRows: Readonly<Ref<readonly number[]>>;
+    expandRow(rowIndex: number): void;
+    collapseRow(rowIndex: number): void;
+    toggleRowExpansion(rowIndex: number): void;
+    expandAllRows(): void;
+    collapseAllRows(): void;
+    isRowExpanded(rowIndex: number): boolean;
+    getExpandedRowIndices(): readonly number[];
+    pinRowTop(rowIndex: number): void;
+    pinRowBottom(rowIndex: number): void;
+    unpinRow(rowIndex: number): void;
+    unpinAllRows(): void;
+    isRowPinnedTop(rowIndex: number): boolean;
+    isRowPinnedBottom(rowIndex: number): boolean;
+    getPinnedTopRowIndices(): readonly number[];
+    getPinnedBottomRowIndices(): readonly number[];
+    setCellMeta<T>(rowIndex: number, columnIndex: number, key: string, value: T): void;
+    getCellMeta<T>(rowIndex: number, columnIndex: number, key: string): T | undefined;
+    hasCellMeta(rowIndex: number, columnIndex: number, key: string): boolean;
+    clearCellMeta(rowIndex: number, columnIndex: number): void;
+    clearCellMetaKey(rowIndex: number, columnIndex: number, key: string): void;
+    setRowMeta<T>(rowIndex: number, key: string, value: T): void;
+    getRowMeta<T>(rowIndex: number, key: string): T | undefined;
+    hasRowMeta(rowIndex: number, key: string): boolean;
+    clearRowMeta(rowIndex: number): void;
+    clearRowMetaKey(rowIndex: number, key: string): void;
+    setColumnMeta<T>(columnIndex: number, key: string, value: T): void;
+    getColumnMeta<T>(columnIndex: number, key: string): T | undefined;
+    hasColumnMeta(columnIndex: number, key: string): boolean;
+    clearColumnMeta(columnIndex: number): void;
+    clearColumnMetaKey(columnIndex: number, key: string): void;
+    onRowAdd(callback: (rowData: unknown[], rowIndex: number) => void): () => void;
+    onRowRemove(callback: (rowData: unknown[], rowIndex: number) => void): () => void;
+    onRowUpdate(callback: (rowIndex: number, oldRowData: unknown[], newRowData: unknown[]) => void): () => void;
+    onCellChange(callback: (rowIndex: number, columnIndex: number, oldValue: unknown, newValue: unknown) => void): () => void;
+    onRowSelectionChange(callback: (selectedIndices: ReadonlySet<number>) => void): () => void;
+    onCellSelectionChange(callback: (selectedCells: ReadonlySet<string>) => void): () => void;
+    onSortChange(callback: (columnIndex: number | null, ascending: boolean) => void): () => void;
+    onFilterChange(callback: (filteredIndices: readonly number[]) => void): () => void;
+    onCellFocusChange(callback: (cell: CellPosition | null) => void): () => void;
+    onColumnVisibilityChange(callback: (columnIndex: number, visible: boolean) => void): () => void;
+    beginBatchUpdate(): void;
+    endBatchUpdate(): void;
+    cancelBatchUpdate(): void;
+    isBatchUpdating(): boolean;
+    batchUpdate(callback: () => void): void;
+    readonly tableLoading: Readonly<Ref<boolean>>;
+    setTableLoading(loading: boolean): void;
+    setCellLoading(rowIndex: number, columnIndex: number, loading: boolean): void;
+    setRowLoading(rowIndex: number, loading: boolean): void;
+    setColumnLoading(columnIndex: number, loading: boolean): void;
+    isTableLoading(): boolean;
+    isCellLoading(rowIndex: number, columnIndex: number): boolean;
+    isRowLoading(rowIndex: number): boolean;
+    isColumnLoading(columnIndex: number): boolean;
+    loadData(fetcher: () => Promise<readonly (readonly unknown[])[]>): Promise<void>;
+    appendRowsAsync(fetcher: () => Promise<readonly (readonly unknown[])[]>): Promise<void>;
+    prependRowsAsync(fetcher: () => Promise<readonly (readonly unknown[])[]>): Promise<void>;
+    readonly frozenLeftColumnCount: Readonly<Ref<number>>;
+    readonly frozenRightColumnCount: Readonly<Ref<number>>;
+    freezeColumnsLeft(count: number): void;
+    freezeColumnsRight(count: number): void;
+    unfreezeColumnsLeft(): void;
+    unfreezeColumnsRight(): void;
+    unfreezeAllColumns(): void;
+    getFrozenLeftColumnCount(): number;
+    getFrozenRightColumnCount(): number;
+    isColumnFrozenLeft(columnIndex: number): boolean;
+    isColumnFrozenRight(columnIndex: number): boolean;
+    hasFrozenColumns(): boolean;
+}
+
+/** Validation error. @public */
+export declare interface ValidationError {
+    row: number;
+    column: number;
+    value: unknown;
+    message: string;
+}
+
+/** Validation result. @public */
+export declare interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+
+/** Virtual scrolling configuration. @public */
+export declare interface VirtualScrollConfig {
+    rowHeight: number;
+    overscan: number;
+    containerHeight: number;
+}
+
+/** Virtual scrolling state. @public */
+export declare interface VirtualScrollState {
+    scrollTop: Ref<number>;
+    rowHeight: number;
+    overscan: number;
+    containerHeight: number;
+    visibleRows: Ref<number[]>;
+    startIndex: Ref<number>;
+    endIndex: Ref<number>;
+    scrollHandler?: () => void;
+    container?: HTMLElement;
+}
+
+export { }