@malva-ui/core 0.1.12

package/data-table/lib/data-table/data-table.d.ts

@@ -0,0 +1,699 @@
+import type { TemplateRef } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvSearchFieldTrigger } from '@malva-ui/core/search-field';
+import type { MlvInfiniteScrollTrigger } from '@malva-ui/cdk/infinite-scroll';
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import { MlvDataSource } from '../data-source';
+import { MlvDataTableCell } from '../data-table-cell';
+import type { MlvDataTableCellContext } from '../data-table-cell';
+import { MlvDataTableEditCell } from '../data-table-edit-cell';
+import { MlvDataTableNoData } from '../data-table-no-data';
+import { MlvDataTableError } from '../data-table-error';
+import type { MlvDataTableErrorContext } from '../data-table-error';
+import { MlvDataTableFooter } from '../data-table-footer';
+import type { MlvFilterState, MlvSortState, MlvSortDirection } from '@malva-ui/cdk/data-source';
+import type { MlvDataTableColumn, MlvDataTableColumnGroup, MlvEditMode, MlvEditEvent, MlvEditSaveEvent, MlvRowClickEvent, MlvSelectableMode, MlvSelectionChangeEvent, MlvPaginationMode, MlvLoadMoreEvent, MlvPinSide, MlvFilterDisplay, MlvColumnResizeEvent } from '../types';
+import type { MlvColumnState, MlvDataRow } from './data-table-layout';
+import * as i0 from "@angular/core";
+import * as i1 from "@malva-ui/cdk/density";
+interface AuxiliaryColumnWidths {
+    selection?: number;
+    actions?: number;
+}
+type AuxiliaryColumnKind = keyof AuxiliaryColumnWidths;
+export declare class MlvDataTable {
+    /** @protected Injected i18n translations for the data table. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvDataTableI18n>;
+    readonly columns: import("@angular/core").InputSignal<MlvDataTableColumn<unknown>[]>;
+    readonly data: import("@angular/core").InputSignal<MlvDataRow[] | MlvDataSource<MlvDataRow> | undefined>;
+    readonly rowHeight: import("@angular/core").InputSignal<number>;
+    /** Enable CDK virtual scroll for large datasets. */
+    readonly virtualScroll: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Alternating row shading. */
+    readonly striped: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Cell border lines. */
+    readonly bordered: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Sticky table header on scroll. */
+    readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Maximum height of the scrollable table area (e.g. `'28rem'`, `'400px'`). Enables vertical scroll. */
+    readonly maxHeight: import("@angular/core").InputSignal<string | undefined>;
+    /** Column group definitions for multi-row headers. */
+    readonly columnGroups: import("@angular/core").InputSignal<MlvDataTableColumnGroup[]>;
+    /** Enable editable mode on the table. */
+    readonly editable: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Edit granularity: `'row'` edits entire rows, `'cell'` edits individual cells. */
+    readonly editMode: import("@angular/core").InputSignal<MlvEditMode>;
+    /** Show an "Add row" button in the toolbar when editable. */
+    readonly addRow: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Show a loading overlay on top of the table. */
+    readonly loading: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Failed-request state. `false` (default) renders normally; `true` renders the
+     * error block with the localized default message; a non-empty string renders
+     * that string as the message.
+     *
+     * While set — and while {@link loading} is falsy — the error block replaces the
+     * table body, taking precedence over both the rows and the `mlvDataTableNoData`
+     * template so a failed request is never mistaken for an empty result set.
+     * Project `<ng-template mlvDataTableError>` to replace the default block.
+     */
+    readonly error: import("@angular/core").InputSignal<string | boolean>;
+    /** Row selection mode: `'single'`, `'multi'`, or `false` to disable. */
+    readonly selectable: import("@angular/core").InputSignal<MlvSelectableMode>;
+    /**
+     * Accessible name for the trailing actions column header (rendered when
+     * {@link editable} is on). The actions `<th>` has no visible label, so this
+     * string is exposed to assistive tech via visually-hidden text to satisfy the
+     * `empty-table-header` requirement. Defaults to `'Actions'`.
+     *
+     * NB: this is a plain English default input rather than a `MLV_DATA_TABLE_I18N`
+     * token entry — adding an i18n string is a follow-up (see `libs-data-table.md`).
+     */
+    readonly actionsHeaderLabel: import("@angular/core").InputSignal<string>;
+    /**
+     * **Experimental.** Opt into full cell-level keyboard navigation backed by the
+     * `@angular/aria` grid pattern (`ngGrid`/`ngGridRow`/`ngGridCell`/`ngGridCellWidget`).
+     *
+     * When `false` (default), the table keeps its stable **row-level** roving
+     * navigation (ArrowUp/Down move between rows, Home/End jump, Space/Enter toggle
+     * row selection). When `true`, arrow keys move focus between individual **cells**
+     * (Arrow keys in both axes, Home/End within a row), interactive cells expose an
+     * `ngGridCellWidget` so Enter pauses grid navigation to interact (edit inputs,
+     * action buttons), and Escape returns to grid navigation.
+     *
+     * Limitations of the current prototype (see `libs-data-table.md`):
+     * - **Requires non-virtual mode.** Cell navigation is inert while
+     *   {@link virtualScroll} is `true` — CDK row recycling and the split
+     *   header/body/footer tables are incompatible with the grid's DOM-registered
+     *   cell/row collection. `virtualScroll` wins; the table falls back to
+     *   row-level roving.
+     * - Row selection stays row-level (via the checkbox widget); the aria grid's
+     *   own cell-selection model is intentionally not wired.
+     */
+    readonly cellNavigation: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Pagination strategy.
+     * - `'paged'` (default) — renders the classic paginator footer and swaps rows per page.
+     * - `'infinite'` — hides the paginator and emits `loadMore` when the user scrolls near the bottom of the scroll container. Consumers should append the new page's rows to the existing data source.
+     */
+    readonly paginationMode: import("@angular/core").InputSignal<MlvPaginationMode>;
+    /**
+     * Whether more data is available to load. Only consulted in `paginationMode: 'infinite'`.
+     * Bind this to the consumer's own "has more pages" flag to stop the directive from
+     * firing once the backing data source has been exhausted.
+     */
+    readonly hasMore: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Distance in px from the bottom of the scrollable area at which `loadMore` fires.
+     * Only consulted in `paginationMode: 'infinite'`. Defaults to `200`.
+     */
+    readonly infiniteScrollThreshold: import("@angular/core").InputSignal<number>;
+    /** Where table-owned filter controls are displayed. */
+    readonly filterDisplay: import("@angular/core").InputSignal<MlvFilterDisplay>;
+    /** Whether the built-in global-search field is rendered in the toolbar. */
+    readonly showSearch: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether global search executes as the user types or only on submit. */
+    readonly searchTrigger: import("@angular/core").InputSignal<MlvSearchFieldTrigger>;
+    /** Delay in milliseconds used by live global search. */
+    readonly searchDebounce: import("@angular/core").InputSignalWithTransform<number, string | number>;
+    /** Emits when a row enters edit mode. */
+    readonly rowEditStart: import("@angular/core").OutputEmitterRef<MlvEditEvent<Record<string, unknown>>>;
+    /** Emits when the user confirms edits on a row. */
+    readonly rowEditSave: import("@angular/core").OutputEmitterRef<MlvEditSaveEvent<Record<string, unknown>>>;
+    /** Emits when the user cancels editing a row. */
+    readonly rowEditCancel: import("@angular/core").OutputEmitterRef<MlvEditEvent<Record<string, unknown>>>;
+    /** Emits when the user clicks "Add row". Consumer is responsible for adding the row. */
+    readonly rowAdd: import("@angular/core").OutputEmitterRef<void>;
+    /** Emits when the user clicks a data row. */
+    readonly rowClick: import("@angular/core").OutputEmitterRef<MlvRowClickEvent<Record<string, unknown>>>;
+    /** Emits when the row selection changes. */
+    readonly selectionChange: import("@angular/core").OutputEmitterRef<MlvSelectionChangeEvent<Record<string, unknown>>>;
+    /**
+     * Emits when the user activates the error block's retry control (the default
+     * "Retry" button, or `retry()` from a custom `mlvDataTableError` template).
+     * The consumer owns the refetch and is responsible for clearing {@link error}.
+     */
+    readonly retry: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * Emits after a pointer or keyboard interaction commits a column width, or
+     * after a reset removes a user width override.
+     */
+    readonly columnResize: import("@angular/core").OutputEmitterRef<MlvColumnResizeEvent>;
+    /**
+     * Emits in `paginationMode: 'infinite'` when the user scrolls near the bottom
+     * of the scroll container. The payload carries the next page number,
+     * current per-page size, and remaining scroll distance.
+     */
+    readonly loadMore: import("@angular/core").OutputEmitterRef<MlvLoadMoreEvent>;
+    /** Two-way bindable set of selected rows. */
+    readonly selectedRows: import("@angular/core").ModelSignal<Set<MlvDataRow>>;
+    /** Applied global-search query. Submit-mode drafts are committed here on search. */
+    readonly searchQuery: import("@angular/core").ModelSignal<string>;
+    readonly cellTemplates: import("@angular/core").Signal<readonly MlvDataTableCell<object>[]>;
+    readonly editCellTemplates: import("@angular/core").Signal<readonly MlvDataTableEditCell<object>[]>;
+    readonly noDataTemplate: import("@angular/core").Signal<readonly MlvDataTableNoData[]>;
+    readonly errorTemplate: import("@angular/core").Signal<readonly MlvDataTableError[]>;
+    readonly footerTemplate: import("@angular/core").Signal<readonly MlvDataTableFooter[]>;
+    readonly tableWrapperRef: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    readonly tableRef: import("@angular/core").Signal<ElementRef<HTMLTableElement> | undefined>;
+    /**
+     * @private Rendered resize separators. Used after rendering to measure
+     * non-pixel CSS widths for accurate initial ARIA values.
+     */
+    private readonly _resizeHandleRefs;
+    /**
+     * @private Toolbar "Filters" trigger button. Focus is returned here when the
+     * filter dialog popup closes, matching the overlay focus-restore pattern.
+     */
+    private readonly _filterTriggerRef;
+    /** @private CDK virtual-scroll viewport (only present in virtual-scroll mode). */
+    private readonly _virtualViewportRef;
+    /** @private DestroyRef used for observable cleanup. */
+    private readonly _destroyRef;
+    /** @private Shared resize-observer service used to track the host width. */
+    private readonly _resizeService;
+    /** @private Owning document for pointer fallback listeners and DOM queries. */
+    private readonly _document;
+    /** @private Host element ref, observed for width and used for row focus queries. */
+    private readonly _el;
+    /** @private Injector used to schedule `afterNextRender` from imperative handlers. */
+    private readonly _injector;
+    /** @private Angular zone — column-resize drag listeners run outside it so pointer moves don't trigger a full CD tick per event (see {@link onResizeStart}). */
+    private readonly _ngZone;
+    /** @private Resolver for ICU parameterized i18n strings. */
+    private readonly _resolver;
+    /**
+     * @protected Flat-rows index of the data row that currently owns the roving
+     * `tabindex="0"`. All other data rows are `tabindex="-1"`, giving the row grid
+     * a single tab stop. Clamped in a constructor effect when `flatRows` changes.
+     */
+    readonly _focusedRowIndex: import("@angular/core").WritableSignal<number>;
+    readonly containerWidth: import("@angular/core").WritableSignal<number>;
+    readonly activeFilters: import("@angular/core").ModelSignal<MlvFilterState[]>;
+    /** @protected Search text currently shown in the toolbar, including submit-mode drafts. */
+    readonly _searchDraft: import("@angular/core").WritableSignal<string>;
+    readonly currentSort: import("@angular/core").WritableSignal<MlvSortState | null>;
+    readonly currentPage: import("@angular/core").WritableSignal<number>;
+    readonly currentPerPage: import("@angular/core").WritableSignal<number>;
+    /** @private Set of currently expanded tree rows (by original row reference). */
+    private readonly _expanded;
+    /** @private User-resized column widths keyed by column key (px). Committed once per completed pointer drag. */
+    private readonly _columnWidths;
+    /**
+     * @private Live width (px) of the column currently being drag-resized, applied
+     * optimistically during the drag before the committed {@link _columnWidths} map is
+     * updated on pointer release. `null` when no resize is in progress. Kept separate from
+     * {@link _columnWidths} so a move updates a single lightweight signal instead of
+     * cloning the whole widths map every frame.
+     */
+    private readonly _liveResize;
+    /**
+     * @private Last DOM-resolved bounds for each resize handle. CSS lengths such
+     * as `rem` can be resolved to pixels from the rendered header during an
+     * interaction and then reused by the separator's ARIA attributes.
+     */
+    private readonly _resolvedResizeBounds;
+    /**
+     * @private Rendered header widths keyed by column. This supplies accurate
+     * separator values when a column's declared width uses `rem`, `%`, or layout.
+     */
+    private readonly _measuredColumnWidths;
+    /** @private Rendered widths of the optional selection and actions columns. */
+    private readonly _measuredAuxiliaryWidths;
+    /** @protected Native vertical-scrollbar width inside the virtual viewport. */
+    protected readonly _virtualScrollbarGutter: import("@angular/core").WritableSignal<number>;
+    /**
+     * @protected Inert outer scroll width that reproduces the virtual viewport's
+     * native horizontal range without changing any split table's layout.
+     */
+    protected readonly _virtualHorizontalScrollExtent: import("@angular/core").WritableSignal<number>;
+    /** @private Whether table geometry is currently frozen to explicit pixel widths. */
+    private readonly _columnLayoutFrozen;
+    /**
+     * @private Exact measured utility-column styles used once data columns are
+     * frozen. Keeping selection/actions cells and their `<col>` elements on the
+     * same widths prevents fixed table layout from redistributing data columns.
+     */
+    private readonly _auxiliaryColumnStyles;
+    /**
+     * @private Per-row cache of the cell-template `ngTemplateOutletContext`, keyed by the
+     * flattened row object identity (see {@link getCellContext}). A `WeakMap` so entries
+     * for rows dropped by a `flatRows()` recompute are reclaimed automatically.
+     */
+    private readonly _cellContextCache;
+    /** @private Stable one-column arrays used by repeated header filter editors. */
+    private readonly _columnFilterLists;
+    /** @private Editing state moved to MlvDataTableEditingService. */
+    private readonly _editing;
+    /** @private Column visibility state moved to MlvDataTableColumnVisibilityService. */
+    private readonly _visibility;
+    /** @private Pin override state moved to MlvDataTablePinningService. */
+    private readonly _pinning;
+    readonly effectiveDataSource: import("@angular/core").Signal<MlvDataSource<MlvDataRow>>;
+    readonly displayRows: import("@angular/core").Signal<MlvDataRow[]>;
+    readonly flatRows: import("@angular/core").Signal<MlvDataRow[]>;
+    readonly totalItems: import("@angular/core").Signal<number>;
+    readonly shownItems: import("@angular/core").Signal<number>;
+    readonly visibleColumns: import("@angular/core").Signal<MlvColumnState[]>;
+    readonly pinnedLeftColumns: import("@angular/core").Signal<MlvColumnState[]>;
+    readonly pinnedRightColumns: import("@angular/core").Signal<MlvColumnState[]>;
+    readonly columnOffsets: import("@angular/core").Signal<Map<string, string>>;
+    /**
+     * Exact table width used while at least one column has a live or committed
+     * user override. Freezing every measured column and the table to the same
+     * pixel sum prevents `width: 100%` table layout from redistributing the
+     * committed width. All virtual split tables and their viewport consume this
+     * same value.
+     */
+    readonly resizedTableWidth: import("@angular/core").Signal<number | null>;
+    /**
+     * @private Memoized inline `[style]` object per visible column, keyed by column key.
+     * Rebuilt only when {@link visibleColumns} or {@link columnOffsets} change (width /
+     * pin / visibility / responsive / live-resize changes). Cell `[style]` bindings read
+     * this map through {@link getCellStyle} so they receive a *stable* object reference
+     * across change-detection cycles instead of a freshly allocated `Record` per cell per
+     * CD; the header and body cells of a column share one object.
+     */
+    private readonly _columnStyles;
+    /**
+     * @private Display cell templates resolved to a `Map<columnKey, TemplateRef>`, rebuilt
+     * only when the projected {@link cellTemplates} set changes. Replaces a per-cell
+     * `Array.find()` on every CD ({@link getTemplate}). First registration wins for
+     * duplicate keys, preserving the previous `find()` (first-match) semantics.
+     */
+    private readonly _cellTemplateMap;
+    /**
+     * @private Edit-mode cell templates resolved to a `Map<columnKey, TemplateRef>`,
+     * rebuilt only when the projected {@link editCellTemplates} set changes. Replaces a
+     * per-cell `Array.find()` on every CD ({@link getEditTemplate}). First registration
+     * wins for duplicate keys.
+     */
+    private readonly _editCellTemplateMap;
+    /**
+     * @protected Whether the experimental aria cell-level grid navigation is
+     * active. Gated to non-virtual mode: `virtualScroll` recycles rows out of the
+     * DOM, which the aria grid's DOM-registered row/cell collection cannot track,
+     * so cell navigation yields to the stable row-roving path when virtual scroll
+     * is on.
+     */
+    readonly _cellNav: import("@angular/core").Signal<boolean>;
+    /**
+     * Whether the error block replaces the table body. An in-flight refetch wins:
+     * while `loading` is truthy the previous error is suppressed so the loader is
+     * not competing with a stale failure message.
+     */
+    readonly showError: import("@angular/core").Signal<boolean>;
+    /**
+     * Message rendered by the error block: the `error` string when one was
+     * supplied, otherwise the localized `errorMessage` default.
+     */
+    readonly errorMessage: import("@angular/core").Signal<string>;
+    /**
+     * @private Stable `retry()` callback handed to the `mlvDataTableError`
+     * template context, so the context object identity only changes with the
+     * message.
+     */
+    private readonly _emitRetry;
+    /**
+     * @protected `ngTemplateOutletContext` for a projected `mlvDataTableError`
+     * template.
+     */
+    protected readonly _errorContext: import("@angular/core").Signal<MlvDataTableErrorContext>;
+    /**
+     * @private Per-column raw-value → label lookup, memoized from
+     * `visibleColumns()`. Falls back to `filterConfig.options` when a column
+     * declares no explicit `valueLabels`. Keys are stringified raw values.
+     */
+    private readonly _columnValueLabels;
+    readonly hasFilters: import("@angular/core").Signal<boolean>;
+    /** Columns included in the global query, independent of responsive visibility. */
+    readonly searchableColumns: import("@angular/core").Signal<MlvDataTableColumn<unknown>[]>;
+    /** Stable key list passed to the data source for OR-across-columns search. */
+    readonly searchableColumnKeys: import("@angular/core").Signal<string[]>;
+    /** Whether a global search field belongs in the toolbar. */
+    readonly hasSearchableColumns: import("@angular/core").Signal<boolean>;
+    /** Whether any configured column supports filtering. */
+    readonly hasFilterableColumns: import("@angular/core").Signal<boolean>;
+    /** Localized active-filter summary announced when the committed set changes. */
+    readonly activeFilterLabel: import("@angular/core").Signal<string>;
+    /** Total number of rendered columns (visible + selection checkbox + actions). */
+    readonly totalColumnCount: import("@angular/core").Signal<number>;
+    /**
+     * Pixel/CSS height applied to the `cdk-virtual-scroll-viewport` when `virtualScroll` is on.
+     * Falls back to `'24rem'` if `maxHeight` is not provided. The viewport requires an explicit
+     * height because `cdk-virtual-scroll-viewport` does not derive its size from its content.
+     */
+    readonly virtualViewportHeight: import("@angular/core").Signal<string>;
+    /** Whether any column has `hideable: true`. */
+    readonly hasHideableColumns: import("@angular/core").Signal<boolean>;
+    /** Whether the toolbar has a visible control or table-owned status to render. */
+    readonly hasToolbarContent: import("@angular/core").Signal<boolean>;
+    /** All columns (for column visibility popup). */
+    readonly allColumns: import("@angular/core").Signal<MlvDataTableColumn<unknown>[]>;
+    /** Whether all visible rows are selected. */
+    readonly allRowsSelected: import("@angular/core").Signal<boolean>;
+    /** Whether some (but not all) rows are selected. */
+    readonly someRowsSelected: import("@angular/core").Signal<boolean>;
+    /** Whether the table has multi-row column groups defined. */
+    readonly hasColumnGroups: import("@angular/core").Signal<boolean>;
+    /**
+     * Computes the group header row layout.
+     * Columns covered by a group get colspan in the group row.
+     * Standalone columns (not in any group) get rowspan="2" in the main header row.
+     */
+    readonly headerLayout: import("@angular/core").Signal<{
+        groupCells: {
+            type: "group";
+            group: MlvDataTableColumnGroup;
+            colspan: number;
+        }[];
+        standaloneKeys: Set<string>;
+        groupedKeys: Set<string>;
+    } | null>;
+    constructor();
+    /** Resolves the custom display template for a column key (if any). */
+    getTemplate(key: string): TemplateRef<unknown> | null;
+    getNoDataTemplate(): TemplateRef<unknown> | null;
+    /**
+     * `ngTemplateOutletContext` for a data cell's custom/edit template. Returns a
+     * *stable* per-row object so the outlet's context does not churn (fresh object +
+     * `NgTemplateOutlet.ngOnChanges`) every change-detection cycle. `flatRows()` rebuilds
+     * its row objects on every data / sort / filter / expand change, so a cached entry's
+     * `index` always matches that row's current position and stale entries (whose row
+     * objects are no longer referenced) are garbage-collected.
+     */
+    getCellContext(row: MlvDataRow, index: number): MlvDataTableCellContext<MlvDataRow>;
+    getCellValue(row: MlvDataRow, key: string): unknown;
+    /**
+     * Value rendered by the **default** cell renderer. Maps the raw value through
+     * the column's `valueLabels` (or its `filterConfig.options` fallback) when a
+     * label exists; otherwise returns the raw value unchanged. Custom
+     * `mlvDataTableCell` templates bypass this entirely.
+     */
+    getCellDisplayValue(row: MlvDataRow, col: MlvDataTableColumn): unknown;
+    /**
+     * Resolves the semantic tone for one default-rendered cell. Returns `null`
+     * when the column declares no `tone` (or its resolver opted this row out), in
+     * which case the cell renders as plain text instead of a badge.
+     */
+    getCellTone(row: MlvDataRow, col: MlvDataTableColumn): MlvTone | null;
+    /** Retrieves the projected error template, if the consumer supplied one. */
+    getErrorTemplate(): TemplateRef<MlvDataTableErrorContext> | null;
+    /** Emits `retry` so the consumer can refetch the failed request. */
+    onRetry(): void;
+    /** Resolves the edit-mode template for a column key (if any). */
+    getEditTemplate(key: string): TemplateRef<unknown> | null;
+    /** Whether a given row index is currently being edited. */
+    isEditing(index: number): boolean;
+    /** Enter edit mode for a row. Clones the row for rollback. */
+    startEdit(row: MlvDataRow, index: number): void;
+    /** Confirm edits for a row. Emits save event with original and modified row. */
+    saveEdit(row: MlvDataRow, index: number): void;
+    /** Cancel editing. Emits cancel event. */
+    cancelEdit(row: MlvDataRow, index: number): void;
+    /** Emit add-row event. Consumer is responsible for appending the new row. */
+    onAddRow(): void;
+    /** Handle click on a data row. */
+    onRowClick(row: MlvDataRow, index: number, event: MouseEvent): void;
+    /**
+     * @protected Roving tabindex for a data row: `0` for the focused row, `-1`
+     * otherwise, so the row grid exposes a single tab stop.
+     */
+    _rowTabIndex(index: number): number;
+    /**
+     * @protected Sync the roving row index when a row receives focus (via Tab or
+     * a click that focuses the `<tr>`).
+     */
+    _onRowFocus(index: number): void;
+    /**
+     * @protected Row-level keyboard navigation for the `role="grid"` table.
+     * Active only when the `<tr>` itself holds focus — keys originating from an
+     * interactive cell widget (checkbox, button, edit input) are left alone.
+     *
+     * - `ArrowUp` / `ArrowDown` — move row focus by one (clamped)
+     * - `Home` / `End` — jump to the first / last row
+     * - `Space` / `Enter` — toggle selection of the focused row when selectable
+     */
+    _onRowKeydown(index: number, row: MlvDataRow, event: KeyboardEvent): void;
+    /**
+     * @private Move the roving tabindex and DOM focus to the row at `targetIndex`.
+     * In virtual-scroll mode the target may be recycled out of the DOM, so it is
+     * scrolled into view first and focused after the next render.
+     */
+    private _moveRowFocus;
+    /** @private Focus the rendered `<tr>` for the given flat-rows index, if present. */
+    private _focusRowElement;
+    /**
+     * Handler wired to `MlvInfiniteScroll.loadMore` when `paginationMode === 'infinite'`.
+     * Increments the tracked page counter and emits a table-level `MlvLoadMoreEvent`
+     * whose `page` field tells the consumer which page to fetch next.
+     */
+    onInfiniteScrollLoadMore(trigger: MlvInfiniteScrollTrigger): void;
+    /** Whether a specific row is currently selected. */
+    isRowSelected(row: MlvDataRow): boolean;
+    /** Toggle selection for a single row. */
+    toggleRowSelection(row: MlvDataRow): void;
+    /** Toggle select-all / deselect-all. */
+    toggleSelectAll(): void;
+    /** Whether a column is currently hidden by the user. */
+    isColumnHidden(key: string): boolean;
+    /** Toggle visibility of a hideable column. */
+    toggleColumnVisibility(key: string): void;
+    /**
+     * @protected Returns focus to the toolbar "Filters" trigger when the filter
+     * dialog popup closes (Apply / Clear / Escape / backdrop), so keyboard focus
+     * is never stranded on a destroyed overlay control.
+     */
+    _onFiltersClosed(): void;
+    /** Commits a search-field event and resets table pagination. */
+    onSearch(query: string): void;
+    /** Whether a column currently has a committed filter. */
+    isColumnFiltered(key: string): boolean;
+    /** Accessible label for a column filter trigger. */
+    getFilterLabel(col: MlvDataTableColumn): string;
+    /**
+     * Merges a scoped editor result against the table's current committed state.
+     * The table remains authoritative here because an overlay may hold an older
+     * input snapshot while another column is committed.
+     */
+    onColumnFiltersChange(key: string, scopedFilters: MlvFilterState[]): void;
+    /** Single-column list consumed by the scoped filter editor. */
+    getColumnFilterColumns(col: MlvDataTableColumn): MlvDataTableColumn[];
+    /** Restores focus to the header filter trigger for a popup that just closed. */
+    focusColumnFilterTrigger(key: string): void;
+    /** Retrieves the footer summary template. */
+    getFooterTemplate(): TemplateRef<unknown> | null;
+    /**
+     * Returns the list of sides the user may pin a column to, based on `col.pinnable`.
+     * - `true` → `['left', 'right']`
+     * - `'left'` / `'right'` → single-element list
+     * - `MlvPinSide[]` → the list as provided (duplicates preserved by caller)
+     * - falsy → `[]` (not user-pinnable)
+     */
+    getPinnableSides(col: MlvDataTableColumn): MlvPinSide[];
+    /** Pin a column to the given side, or unpin if it is already pinned. */
+    togglePin(col: MlvDataTableColumn, side?: MlvPinSide): void;
+    /** Pin a column to a specific side, overriding any current pin state. */
+    pinTo(col: MlvDataTableColumn, side: MlvPinSide): void;
+    /** Explicitly unpin a column, regardless of its current side. */
+    unpin(col: MlvDataTableColumn): void;
+    /** Whether a column is currently pinned (accounting for overrides). */
+    isColumnPinned(col: MlvDataTableColumn): boolean;
+    /** Returns the current pin side for a column (considering overrides), or `null` if it is not pinned. */
+    getColumnPinSide(col: MlvDataTableColumn): MlvPinSide | null;
+    isRowExpanded(row: MlvDataRow): boolean;
+    hasChildren(row: MlvDataRow): boolean;
+    getDepth(row: MlvDataRow): number;
+    toggleExpand(row: MlvDataRow, event: Event): void;
+    onSortClick(col: MlvDataTableColumn): void;
+    getSortDirection(col: MlvDataTableColumn): MlvSortDirection | null;
+    /**
+     * Accessible label for a sortable column header button. Resolves the
+     * `sortByColumn` ICU string ("Sort by {column}") — describing intent rather
+     * than a mouse-specific "click to sort" instruction.
+     */
+    getSortLabel(col: MlvDataTableColumn): string;
+    getColStyle(col: MlvColumnState): Record<string, string>;
+    /**
+     * Returns the value to apply to a `<col>` element's `width` style.
+     * Used by the shared `<colgroup>` template to keep column widths in sync between the
+     * three split tables in virtual scroll mode (header / body / footer).
+     */
+    getColWidth(col: MlvColumnState): string | null;
+    /** Exact frozen width styles for a selection or actions utility column. */
+    protected getAuxiliaryColumnStyle(kind: AuxiliaryColumnKind): Readonly<Record<string, string>> | null;
+    /** Exact frozen `<col>` width for a selection or actions utility column. */
+    protected getAuxiliaryColumnWidth(kind: AuxiliaryColumnKind): string | null;
+    /**
+     * trackBy used by `*cdkVirtualFor` in virtual scroll mode. Falls back to the row index
+     * for plain row references and to `_mlvRef` identity for tree rows so expanded children
+     * are reconciled correctly when the user scrolls.
+     */
+    trackByRow: (index: number, row: MlvDataRow) => unknown;
+    /**
+     * Inline `[style]` object (width / min-width, plus sticky offsets for pinned columns)
+     * for a column's header and body cells. Reads the memoized {@link _columnStyles} map
+     * so the returned reference is stable across change-detection cycles (no per-cell
+     * allocation). Every visible column is present in the map; the on-the-fly fallback is
+     * a defensive path for a column outside the current visible set.
+     */
+    getCellStyle(col: MlvColumnState): Record<string, string>;
+    getAlignClass(col: MlvDataTableColumn): string;
+    /**
+     * @private In-flight pointer resize state. The originating pointer id prevents
+     * secondary touches or unrelated pointers from moving or ending the drag.
+     */
+    private _resizeState;
+    /**
+     * @private rAF handle coalescing live-width signal writes to one per frame
+     * during a pointer drag.
+     */
+    private _resizeRafId;
+    /**
+     * @private Bound pointer-move handler retained so add/removeEventListener use
+     * the same function reference.
+     */
+    private readonly _onResizeMoveBound;
+    /**
+     * @private Bound pointer-up handler retained so add/removeEventListener use
+     * the same function reference.
+     */
+    private readonly _onResizeEndBound;
+    /**
+     * @private Bound pointer-cancel handler. Cancellation restores the previously
+     * committed width and never emits a commit event.
+     */
+    private readonly _onResizeCancelBound;
+    /**
+     * @private Cancels an active drag if the browser unexpectedly revokes the
+     * initiating handle's pointer capture.
+     */
+    private readonly _onResizeLostCaptureBound;
+    /**
+     * Starts a column resize with Pointer Events and captures the initiating
+     * pointer on the separator. The rendered header width is measured instead of
+     * trusting the declared CSS width, so `rem`, `%`, and flex/table layout widths
+     * begin without a jump.
+     */
+    onResizeStart(col: MlvColumnState, event: PointerEvent): void;
+    /**
+     * Handles keyboard resizing for the focusable separator. ArrowLeft/ArrowRight
+     * use an 8px step (32px with Shift); Home/End jump to the resolved bounds.
+     */
+    onColumnResizeKeydown(col: MlvColumnState, event: KeyboardEvent): void;
+    /** Localized accessible name for a column's resize separator. */
+    getColumnResizeLabel(col: MlvDataTableColumn): string;
+    /** Current separator value in CSS pixels for ARIA. */
+    getColumnResizeValue(col: MlvColumnState): number;
+    /** Minimum separator value in CSS pixels for ARIA and Home. */
+    getColumnResizeMin(col: MlvDataTableColumn): number;
+    /** Maximum separator value in CSS pixels for ARIA and End. */
+    getColumnResizeMax(col: MlvDataTableColumn): number;
+    /** Localized text alternative that makes the separator's pixel unit explicit. */
+    getColumnResizeValueText(col: MlvColumnState): string;
+    /**
+     * Removes committed user widths. Passing a key resets that column and emits a
+     * reset even when no override exists (useful for clearing persisted state);
+     * omitting it resets every currently overridden column.
+     */
+    resetColumnWidth(key?: string): void;
+    /**
+     * @private Pointer-move handler (outside Angular). It synchronously updates
+     * the latest bounded value, then publishes at most one live signal update per
+     * animation frame.
+     */
+    private _onResizeMove;
+    /**
+     * @private Pointer-up handler that commits exactly once for the initiating
+     * pointer. A press/release without movement remains a no-op, which keeps a
+     * double-click reset from producing intermediate resize commits.
+     */
+    private _onResizeEnd;
+    /**
+     * @private Cancels only the matching active pointer, dropping the optimistic
+     * live width while preserving the last committed map entry.
+     */
+    private _onResizeCancel;
+    /**
+     * @private Treats unexpected capture loss as cancellation. Normal cleanup
+     * removes this listener before explicitly releasing capture, so pointer-up
+     * commits cannot be mistaken for cancellation.
+     */
+    private _onResizeLostCapture;
+    /**
+     * @private Commits a bounded pixel width with one map clone and emits the
+     * public persistence event in the same Angular-zone turn.
+     */
+    private _commitColumnWidth;
+    /**
+     * @private Returns the latest DOM-resolved bounds when available, otherwise
+     * resolves strict pixel metadata with safe finite defaults.
+     */
+    private _columnResizeBounds;
+    /** @private Stores DOM-resolved bounds with a signal-safe map replacement. */
+    private _cacheColumnResizeBounds;
+    /**
+     * @private Resolves resize bounds. Non-pixel metadata is read back from the
+     * rendered header's computed style where the browser exposes a pixel value.
+     */
+    private _resolveColumnResizeBounds;
+    /**
+     * @private Resolves a declared bound to CSS pixels. Complete pixel values are
+     * direct; complete percentages use the rendered header table width, matching
+     * the containing table against which cell percentages are laid out.
+     */
+    private _resolveColumnBound;
+    /** @private Parses a complete, non-negative CSS percentage as a fraction. */
+    private _parseCssPercentage;
+    /**
+     * @private Re-applies outer horizontal position after virtual DOM/geometry
+     * changes that do not themselves emit another wrapper scroll event.
+     */
+    private _syncVirtualHorizontalScroll;
+    /**
+     * @private Publishes both the native vertical-scrollbar width and an inert
+     * outer extent whose maximum scroll position exactly matches the viewport.
+     */
+    private _updateVirtualScrollGeometry;
+    /**
+     * @private Measures the actual rendered header cell width and falls back to
+     * the current strict-pixel state only in non-layout environments such as
+     * server rendering and jsdom.
+     */
+    private _measureHeaderWidth;
+    /**
+     * @private Measures the rendered header once per layout change. Before the
+     * first user override these values track responsive/table layout; while the
+     * table is frozen, existing baselines are preserved so reset restores the
+     * original widths rather than another column's resized layout.
+     */
+    private _measureHeaderWidths;
+    /**
+     * @private CSS length used by a sticky offset. A rendered measurement is more
+     * accurate than declared CSS under table redistribution; the declaration
+     * remains the pre-render/SSR fallback.
+     */
+    private _columnOffsetWidth;
+    /** @private Adds heterogeneous CSS lengths without converting their units. */
+    private _sumCssLengths;
+    /** @private Rounds pixel values to hundredths without changing their bounds. */
+    private _roundColumnWidth;
+    /** @private Creates immutable exact width/min/max styles for a measured column. */
+    private _fixedColumnWidthStyles;
+    /** @private Rounds and clamps a width against normalized finite bounds. */
+    private _normalizeColumnWidth;
+    /** @private Clamps a width to finite normalized resize bounds. */
+    private _clampColumnWidth;
+    /**
+     * @private Detaches active pointer listeners, releases capture, cancels a
+     * pending animation frame, and clears the drag state. Idempotent for pointer
+     * up, pointer cancel, reset, and component destruction.
+     */
+    private _cleanupResize;
+    /** Returns the original (pre-spread) row reference for expand tracking. */
+    private _ref;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDataTable, "mlv-data-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "columnGroups": { "alias": "columnGroups"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": false; "isSignal": true; }; "addRow": { "alias": "addRow"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "actionsHeaderLabel": { "alias": "actionsHeaderLabel"; "required": false; "isSignal": true; }; "cellNavigation": { "alias": "cellNavigation"; "required": false; "isSignal": true; }; "paginationMode": { "alias": "paginationMode"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "infiniteScrollThreshold": { "alias": "infiniteScrollThreshold"; "required": false; "isSignal": true; }; "filterDisplay": { "alias": "filterDisplay"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "searchTrigger": { "alias": "searchTrigger"; "required": false; "isSignal": true; }; "searchDebounce": { "alias": "searchDebounce"; "required": false; "isSignal": true; }; "selectedRows": { "alias": "selectedRows"; "required": false; "isSignal": true; }; "searchQuery": { "alias": "searchQuery"; "required": false; "isSignal": true; }; "activeFilters": { "alias": "activeFilters"; "required": false; "isSignal": true; }; }, { "rowEditStart": "rowEditStart"; "rowEditSave": "rowEditSave"; "rowEditCancel": "rowEditCancel"; "rowAdd": "rowAdd"; "rowClick": "rowClick"; "selectionChange": "selectionChange"; "retry": "retry"; "columnResize": "columnResize"; "loadMore": "loadMore"; "selectedRows": "selectedRowsChange"; "searchQuery": "searchQueryChange"; "activeFilters": "activeFiltersChange"; }, ["cellTemplates", "editCellTemplates", "noDataTemplate", "errorTemplate", "footerTemplate"], never, true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}
+export {};