@malva-ui/core 0.1.13 → 0.1.14

package/types/malva-ui-core-data-table.d.ts

@@ -0,0 +1,1074 @@
+import { MlvTone } from '@malva-ui/cdk/utils';
+import { MlvDataSourceFilterOperator, MlvSortState, MlvDataSource, MlvFilterState, MlvSortDirection } from '@malva-ui/cdk/data-source';
+export * from '@malva-ui/cdk/data-source';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvSearchFieldTrigger } from '@malva-ui/core/search-field';
+export { MlvSearchFieldTrigger } from '@malva-ui/core/search-field';
+import { MlvInfiniteScrollTrigger } from '@malva-ui/cdk/infinite-scroll';
+import * as i1 from '@malva-ui/cdk/density';
+
+/** @deprecated Use `MlvDataSourceFilterOperator` from `@malva-ui/cdk/data-source`. */
+type MlvDataTableFilterOperator = MlvDataSourceFilterOperator;
+interface MlvDataTableFilterOption {
+    label: string;
+    value: unknown;
+}
+/** Where filter controls are presented by the data table. */
+type MlvFilterDisplay = 'toolbar' | 'column' | 'none';
+interface MlvColumnFilterConfig {
+    options?: MlvDataTableFilterOption[];
+    operators?: MlvDataSourceFilterOperator[];
+}
+type MlvColumnResponsive = Record<string | number, 'hidden' | 'visible'>;
+type MlvColumnAlign = 'left' | 'center' | 'right';
+/** Side a column can be pinned to. */
+type MlvPinSide = 'left' | 'right';
+/**
+ * Maps raw cell values to human-readable labels for a column's default cell
+ * renderer. Either an object keyed by the stringified raw value, or the same
+ * `{ label, value }` option list already used by `filterConfig.options`.
+ */
+type MlvColumnValueLabels = Record<string, string> | ReadonlyArray<MlvDataTableFilterOption>;
+/**
+ * Resolves the semantic tone of one row so a column's default cell can render a
+ * toned `mlv-badge`. Returning `null`/`undefined` falls back to plain text.
+ *
+ * Declared through the method-syntax bivariance form so a column list authored
+ * against a concrete row type (`MlvDataTableColumn<User>[]`) stays assignable to
+ * the table's `MlvDataTableColumn[]` input.
+ */
+type MlvColumnToneFn<T = unknown> = {
+    bivarianceHack(row: T): MlvTone | null | undefined;
+}['bivarianceHack'];
+interface MlvDataTableColumn<T = unknown> {
+    key: string;
+    title?: string;
+    sortable?: boolean;
+    /** Include this column in the table's global search. */
+    searchable?: boolean;
+    filterable?: boolean;
+    /**
+     * Controls whether the user can toggle the pin state via the header pin button, and which sides are allowed.
+     * - `true` — both sides allowed (clicking opens a popup with Pin Left / Pin Right / Unpin options).
+     * - `'left'` / `'right'` — only the given side is allowed; clicking the pin button toggles directly.
+     * - `['left', 'right']` — explicit list of allowed sides. A single-element list behaves like the direct-toggle string form; a multi-element list opens the popup.
+     * - `false` / `undefined` — the column cannot be user-pinned (it may still be pinned at load time via `pinned`/`pinSide`).
+     */
+    pinnable?: boolean | MlvPinSide | MlvPinSide[];
+    pinned?: boolean;
+    pinSide?: MlvPinSide;
+    hideable?: boolean;
+    align?: MlvColumnAlign;
+    resizable?: boolean;
+    width?: string;
+    minWidth?: string;
+    /** Maximum width allowed while resizing. Pixel and percentage values are resolved to rendered CSS pixels. */
+    maxWidth?: string;
+    responsive?: MlvColumnResponsive;
+    filterConfig?: MlvColumnFilterConfig;
+    /**
+     * Human-readable labels for the raw values of this column, used by the
+     * **default** cell renderer only (a `mlvDataTableCell` template still wins).
+     * Accepts a `Record<rawValue, label>` or a `{ label, value }` list.
+     *
+     * When omitted, the table falls back to `filterConfig.options`, so a column
+     * that already declares option filters renders its option labels for free.
+     */
+    valueLabels?: MlvColumnValueLabels;
+    /**
+     * Semantic tone for the default cell renderer. When set (either a fixed
+     * {@link MlvTone} or a per-row resolver), the default cell renders the value
+     * as a muted `mlv-badge` instead of plain text. A resolver returning
+     * `null`/`undefined` renders that row's cell as plain text.
+     *
+     * Ignored when a `mlvDataTableCell` template is provided for the column.
+     */
+    tone?: MlvTone | MlvColumnToneFn<T>;
+}
+/** Interaction that committed a user-controlled column width. */
+type MlvColumnResizeSource = 'pointer' | 'keyboard' | 'reset';
+/** Payload emitted after a column width is committed or reset. */
+interface MlvColumnResizeEvent {
+    /** Key of the resized column. */
+    key: string;
+    /**
+     * Committed width in CSS pixels. `null` means the user override was removed
+     * and the column returned to its declared/default width.
+     */
+    width: number | null;
+    /** Interaction that committed the change. */
+    source: MlvColumnResizeSource;
+}
+/**
+ * Durable user-controlled presentation settings for an `mlv-data-table`.
+ * Search, filters, selection, the current page, and loading state are
+ * deliberately excluded because they are transient or application-owned.
+ */
+interface MlvDataTablePresentationState {
+    /** Active column sort, or `null` when no sort is applied. */
+    readonly sort: MlvSortState | null;
+    /** Visible column keys in their declaration order. */
+    readonly visibleColumnKeys: readonly string[];
+    /** Effectively left-pinned column keys in their declaration order. */
+    readonly pinnedStartColumnKeys: readonly string[];
+    /** Effectively right-pinned column keys in their declaration order. */
+    readonly pinnedEndColumnKeys: readonly string[];
+    /** Committed user width overrides in CSS pixels, keyed by column. */
+    readonly columnWidths: Readonly<Record<string, number>>;
+    /** Current items-per-page setting. */
+    readonly perPage: number;
+}
+interface MlvDataTableColumnGroup {
+    /** Display title for the group header cell. */
+    title: string;
+    /** Column keys this group spans. */
+    columns: string[];
+    /** Optional alignment for the group header cell. */
+    align?: MlvColumnAlign;
+}
+type MlvEditMode = 'row' | 'cell';
+interface MlvEditEvent<T = Record<string, unknown>> {
+    row: T;
+    index: number;
+}
+interface MlvEditSaveEvent<T = Record<string, unknown>> {
+    row: T;
+    index: number;
+    originalRow: T;
+}
+interface MlvRowClickEvent<T = Record<string, unknown>> {
+    row: T;
+    index: number;
+    event: MouseEvent;
+}
+type MlvSelectableMode = 'single' | 'multi' | false;
+interface MlvSelectionChangeEvent<T = Record<string, unknown>> {
+    selectedRows: Set<T>;
+    row?: T;
+}
+/** Pagination strategy for the data table. `'paged'` renders the classic paginator footer; `'infinite'` hides it and emits `loadMore` as the user scrolls near the bottom. */
+type MlvPaginationMode = 'paged' | 'infinite';
+/** Payload emitted by the data table when infinite scroll crosses the threshold. */
+interface MlvLoadMoreEvent {
+    /** Next page the consumer should request (1-based). */
+    page: number;
+    /** Items-per-page configured on the table. */
+    perPage: number;
+    /** Distance in px from the bottom of the scroll container when the event fired. */
+    distance: number;
+}
+
+/** Context for DataTableCell templates */
+interface MlvDataTableCellContext<T> {
+    $implicit: T;
+    row: T;
+    index: number;
+}
+/**
+ * Structural directive for providing custom cell templates with full type inference.
+ *
+ * Usage (asterisk shorthand — preferred):
+ * ```html
+ * <mlv-data-table [data]="employees" [columns]="columns">
+ *   <span *mlvDataTableCell="'salary'; let row from employees">
+ *     {{ row.salary.toLocaleString() }}
+ *   </span>
+ * </mlv-data-table>
+ * ```
+ *
+ * Usage (explicit ng-template):
+ * ```html
+ * <ng-template mlvDataTableCell="salary" [mlvDataTableCellFrom]="employees" let-row>
+ *   <span>{{ row.salary.toLocaleString() }}</span>
+ * </ng-template>
+ * ```
+ */
+declare class MlvDataTableCell<T extends object = Record<string, unknown>> {
+    /** Column key this template applies to — typed as `keyof T` when `from` is provided. */
+    readonly columnKey: _angular_core.InputSignal<keyof T & string>;
+    /**
+     * Pass the same value as `[data]` on the parent `mlv-data-table`.
+     * Angular uses this to infer `T` and type `let-row` in the template.
+     */
+    readonly from: _angular_core.InputSignal<MlvDataSource<T> | T[] | undefined>;
+    readonly templateRef: TemplateRef<MlvDataTableCellContext<T>>;
+    /** Narrows the template context to `MlvDataTableCellContext<T>` for type-safe `let-row`. */
+    static ngTemplateContextGuard<T extends object>(_dir: MlvDataTableCell<T>, _ctx: unknown): _ctx is MlvDataTableCellContext<T>;
+    /** Enables `*mlvDataTableCell="'key'; let row from data"` microsyntax. */
+    static ngTemplateGuard_mlvDataTableCellFrom: 'binding';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDataTableCell<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvDataTableCell<any>, "[mlvDataTableCell]", never, { "columnKey": { "alias": "mlvDataTableCell"; "required": true; "isSignal": true; }; "from": { "alias": "mlvDataTableCellFrom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Context for DataTableEditCell templates */
+interface MlvDataTableEditCellContext<T> {
+    $implicit: T;
+    row: T;
+    index: number;
+}
+/**
+ * Structural directive for providing custom edit-mode cell templates.
+ *
+ * When the table is in editable mode and a row enters editing, this template
+ * replaces the display template for the given column key.
+ *
+ * Usage (asterisk shorthand):
+ * ```html
+ * <mlv-input *mlvDataTableEditCell="'name'; let row from employees"
+ *   [ngModel]="row.name" (ngModelChange)="row.name = $event" />
+ * ```
+ *
+ * Usage (explicit ng-template):
+ * ```html
+ * <ng-template mlvDataTableEditCell="name" [mlvDataTableEditCellFrom]="employees" let-row>
+ *   <mlv-input [ngModel]="row.name" (ngModelChange)="row.name = $event" />
+ * </ng-template>
+ * ```
+ */
+declare class MlvDataTableEditCell<T extends object = Record<string, unknown>> {
+    /** Column key this edit template applies to. */
+    readonly columnKey: _angular_core.InputSignal<keyof T & string>;
+    /**
+     * Pass the same value as `[data]` on the parent `mlv-data-table`.
+     * Angular uses this to infer `T` and type `let-row` in the template.
+     */
+    readonly from: _angular_core.InputSignal<MlvDataSource<T> | T[] | undefined>;
+    readonly templateRef: TemplateRef<MlvDataTableEditCellContext<T>>;
+    /** Narrows the template context to `MlvDataTableEditCellContext<T>` for type-safe `let-row`. */
+    static ngTemplateContextGuard<T extends object>(_dir: MlvDataTableEditCell<T>, _ctx: unknown): _ctx is MlvDataTableEditCellContext<T>;
+    /** Enables `*mlvDataTableEditCell="'key'; let row from data"` microsyntax. */
+    static ngTemplateGuard_mlvDataTableEditCellFrom: 'binding';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDataTableEditCell<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvDataTableEditCell<any>, "[mlvDataTableEditCell]", never, { "columnKey": { "alias": "mlvDataTableEditCell"; "required": true; "isSignal": true; }; "from": { "alias": "mlvDataTableEditCellFrom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for the "no data" slot.
+ *
+ * Usage:
+ * ```html
+ * <mlv-data-table ...>
+ *   <ng-template mlvDataTableNoData>
+ *     <p>No records found.</p>
+ *   </ng-template>
+ * </mlv-data-table>
+ * ```
+ */
+declare class MlvDataTableNoData {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDataTableNoData, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvDataTableNoData, "[mlvDataTableNoData]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Template context handed to a `mlvDataTableError` template.
+ */
+interface MlvDataTableErrorContext {
+    /** Resolved error message — the `error` string, or the localized default. */
+    $implicit: string;
+    /** Invoke to emit the table's `(retry)` output. */
+    retry: () => void;
+}
+/**
+ * Directive for the "request failed" slot. Rendered in place of the table body
+ * whenever `[error]` is truthy and the table is not loading, so a failed request
+ * is never mistaken for an empty result set.
+ *
+ * Usage:
+ * ```html
+ * <mlv-data-table [data]="rows()" [columns]="columns" [error]="error()" (retry)="reload()">
+ *   <ng-template mlvDataTableError let-message let-retry="retry">
+ *     <p>{{ message }}</p>
+ *     <button mlvButton variant="secondary" type="button" (click)="retry()">Try again</button>
+ *   </ng-template>
+ * </mlv-data-table>
+ * ```
+ */
+declare class MlvDataTableError {
+    /** The projected template rendered instead of the default error block. */
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * Type guard so Angular narrows `let-message` / `let-retry="retry"` to
+     * {@link MlvDataTableErrorContext} in strict templates.
+     */
+    static ngTemplateContextGuard(_dir: MlvDataTableError, _ctx: unknown): _ctx is MlvDataTableErrorContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDataTableError, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvDataTableError, "[mlvDataTableError]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for the footer summary row slot.
+ *
+ * The template context provides `{ $implicit: columns }` where `columns`
+ * is the current visible column list.
+ *
+ * Usage:
+ * ```html
+ * <mlv-data-table ...>
+ *   <ng-template mlvDataTableFooter let-cols>
+ *     <th scope="row" [attr.colspan]="cols.length - 1">Total</th>
+ *     <td>...</td>
+ *   </ng-template>
+ * </mlv-data-table>
+ * ```
+ *
+ * Direct `th` and `td` children receive the table's density, divider, sticky
+ * surface, and bordered-cell styling without private component classes.
+ */
+declare class MlvDataTableFooter {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDataTableFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvDataTableFooter, "[mlvDataTableFooter]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Optional host-owned actions projected into the Data Table's single toolbar.
+ * The template renders after all table-owned controls.
+ */
+declare class MlvDataTableToolbarActions {
+    /** Projected toolbar-actions template rendered by the owning Data Table. */
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvDataTableToolbarActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvDataTableToolbarActions, "ng-template[mlvDataTableToolbarActions]", never, {}, {}, never, never, true, never>;
+}
+
+/** Internal row shape used while flattening tree data. */
+type MlvDataRow = object & {
+    _mlvChildren?: MlvDataRow[];
+    _mlvDepth?: number;
+    _mlvRef?: MlvDataRow;
+};
+/** Internal column state enriched with measured layout information. */
+interface MlvColumnState extends MlvDataTableColumn {
+    _currentWidth?: number;
+    _left?: number;
+    _right?: number;
+    _visible?: boolean;
+}
+
+interface AuxiliaryColumnWidths {
+    selection?: number;
+    actions?: number;
+}
+type AuxiliaryColumnKind = keyof AuxiliaryColumnWidths;
+declare class MlvDataTable {
+    /** @protected Injected i18n translations for the data table. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvDataTableI18n>;
+    readonly columns: _angular_core.InputSignal<MlvDataTableColumn<unknown>[]>;
+    readonly data: _angular_core.InputSignal<MlvDataRow[] | MlvDataSource<MlvDataRow> | undefined>;
+    readonly rowHeight: _angular_core.InputSignal<number>;
+    /** Enable CDK virtual scroll for large datasets. */
+    readonly virtualScroll: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Alternating row shading. */
+    readonly striped: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Cell border lines. */
+    readonly bordered: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Sticky table header on scroll. */
+    readonly stickyHeader: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Maximum height of the scrollable table area (e.g. `'28rem'`, `'400px'`). Enables vertical scroll. */
+    readonly maxHeight: _angular_core.InputSignal<string | undefined>;
+    /** Column group definitions for multi-row headers. */
+    readonly columnGroups: _angular_core.InputSignal<MlvDataTableColumnGroup[]>;
+    /** Enable editable mode on the table. */
+    readonly editable: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Edit granularity: `'row'` edits entire rows, `'cell'` edits individual cells. */
+    readonly editMode: _angular_core.InputSignal<MlvEditMode>;
+    /** Show an "Add row" button in the toolbar when editable. */
+    readonly addRow: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Show a loading overlay on top of the table. */
+    readonly loading: _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: _angular_core.InputSignal<string | boolean>;
+    /** Row selection mode: `'single'`, `'multi'`, or `false` to disable. */
+    readonly selectable: _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: _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: _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: _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: _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: _angular_core.InputSignal<number>;
+    /** Where table-owned filter controls are displayed. */
+    readonly filterDisplay: _angular_core.InputSignal<MlvFilterDisplay>;
+    /** Whether the built-in global-search field is rendered in the toolbar. */
+    readonly showSearch: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the generic Sort menu is rendered when sortable columns exist. */
+    readonly showSortMenu: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether global search executes as the user types or only on submit. */
+    readonly searchTrigger: _angular_core.InputSignal<MlvSearchFieldTrigger>;
+    /** Delay in milliseconds used by live global search. */
+    readonly searchDebounce: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Emits when a row enters edit mode. */
+    readonly rowEditStart: _angular_core.OutputEmitterRef<MlvEditEvent<Record<string, unknown>>>;
+    /** Emits when the user confirms edits on a row. */
+    readonly rowEditSave: _angular_core.OutputEmitterRef<MlvEditSaveEvent<Record<string, unknown>>>;
+    /** Emits when the user cancels editing a row. */
+    readonly rowEditCancel: _angular_core.OutputEmitterRef<MlvEditEvent<Record<string, unknown>>>;
+    /** Emits when the user clicks "Add row". Consumer is responsible for adding the row. */
+    readonly rowAdd: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the user clicks a data row. */
+    readonly rowClick: _angular_core.OutputEmitterRef<MlvRowClickEvent<Record<string, unknown>>>;
+    /** Emits when the row selection changes. */
+    readonly selectionChange: _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: _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: _angular_core.OutputEmitterRef<MlvColumnResizeEvent>;
+    /**
+     * Emits a complete normalized durable presentation snapshot after a user
+     * changes sorting, column visibility, pinning, committed widths, or page size.
+     * Programmatic {@link applyPresentationState} calls deliberately do not emit.
+     */
+    readonly presentationStateChange: _angular_core.OutputEmitterRef<MlvDataTablePresentationState>;
+    /**
+     * 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: _angular_core.OutputEmitterRef<MlvLoadMoreEvent>;
+    /** Two-way bindable set of selected rows. */
+    readonly selectedRows: _angular_core.ModelSignal<Set<MlvDataRow>>;
+    /** Applied global-search query. Submit-mode drafts are committed here on search. */
+    readonly searchQuery: _angular_core.ModelSignal<string>;
+    readonly cellTemplates: _angular_core.Signal<readonly MlvDataTableCell<object>[]>;
+    readonly editCellTemplates: _angular_core.Signal<readonly MlvDataTableEditCell<object>[]>;
+    readonly noDataTemplate: _angular_core.Signal<readonly MlvDataTableNoData[]>;
+    readonly errorTemplate: _angular_core.Signal<readonly MlvDataTableError[]>;
+    readonly footerTemplate: _angular_core.Signal<readonly MlvDataTableFooter[]>;
+    /** @protected Optional host-owned actions rendered last in the table toolbar. */
+    protected readonly _toolbarActions: _angular_core.Signal<MlvDataTableToolbarActions | undefined>;
+    readonly tableWrapperRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly tableRef: _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 readonly _rtlService;
+    /** @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: _angular_core.WritableSignal<number>;
+    readonly containerWidth: _angular_core.WritableSignal<number>;
+    readonly activeFilters: _angular_core.ModelSignal<MlvFilterState[]>;
+    /** @protected Search text currently shown in the toolbar, including submit-mode drafts. */
+    readonly _searchDraft: _angular_core.WritableSignal<string>;
+    readonly currentSort: _angular_core.WritableSignal<MlvSortState | null>;
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    readonly currentPerPage: _angular_core.WritableSignal<number>;
+    /**
+     * Captures durable user-controlled table presentation in declaration order.
+     * The returned object is safe to persist and excludes transient page state.
+     */
+    getPresentationState(): MlvDataTablePresentationState;
+    /**
+     * Applies only the supplied durable presentation fields after filtering stale
+     * keys and normalizing widths and page size. Applying a snapshot always
+     * returns the transient current page to one and never emits an echo event.
+     */
+    applyPresentationState(state: Partial<MlvDataTablePresentationState>): void;
+    /** @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: _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: _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: _angular_core.Signal<MlvDataSource<MlvDataRow>>;
+    readonly displayRows: _angular_core.Signal<MlvDataRow[]>;
+    readonly flatRows: _angular_core.Signal<MlvDataRow[]>;
+    readonly totalItems: _angular_core.Signal<number>;
+    readonly shownItems: _angular_core.Signal<number>;
+    readonly visibleColumns: _angular_core.Signal<MlvColumnState[]>;
+    readonly pinnedLeftColumns: _angular_core.Signal<MlvColumnState[]>;
+    readonly pinnedRightColumns: _angular_core.Signal<MlvColumnState[]>;
+    readonly columnOffsets: _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: _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: _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: _angular_core.Signal<boolean>;
+    /**
+     * Message rendered by the error block: the `error` string when one was
+     * supplied, otherwise the localized `errorMessage` default.
+     */
+    readonly errorMessage: _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: _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: _angular_core.Signal<boolean>;
+    /** Columns included in the global query, independent of responsive visibility. */
+    readonly searchableColumns: _angular_core.Signal<MlvDataTableColumn<unknown>[]>;
+    /** Stable key list passed to the data source for OR-across-columns search. */
+    readonly searchableColumnKeys: _angular_core.Signal<string[]>;
+    /** Whether a global search field belongs in the toolbar. */
+    readonly hasSearchableColumns: _angular_core.Signal<boolean>;
+    /** Whether any configured column supports filtering. */
+    readonly hasFilterableColumns: _angular_core.Signal<boolean>;
+    /** Whether any configured column supports sorting. */
+    readonly hasSortableColumns: _angular_core.Signal<boolean>;
+    /** Localized active-filter summary announced when the committed set changes. */
+    readonly activeFilterLabel: _angular_core.Signal<string>;
+    /** Total number of rendered columns (visible + selection checkbox + actions). */
+    readonly totalColumnCount: _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: _angular_core.Signal<string>;
+    /** Whether any column has `hideable: true`. */
+    readonly hasHideableColumns: _angular_core.Signal<boolean>;
+    /** Whether the toolbar has a visible control or table-owned status to render. */
+    readonly hasToolbarContent: _angular_core.Signal<boolean>;
+    /** All columns (for column visibility popup). */
+    readonly allColumns: _angular_core.Signal<MlvDataTableColumn<unknown>[]>;
+    /** Whether all visible rows are selected. */
+    readonly allRowsSelected: _angular_core.Signal<boolean>;
+    /** Whether some (but not all) rows are selected. */
+    readonly someRowsSelected: _angular_core.Signal<boolean>;
+    /** Whether the table has multi-row column groups defined. */
+    readonly hasColumnGroups: _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: _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;
+    /** @internal Applies a transient paginator page change without a snapshot. */
+    _onPageChange(page: number): void;
+    /** Applies a durable paginator page-size change and emits one snapshot. */
+    _onPerPageChange(perPage: number): 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;
+    /**
+     * @protected Applies a Sort-menu action, resets pagination, and emits exactly
+     * one presentation snapshot. Programmatic snapshot application remains silent.
+     */
+    protected _applyMenuSort(column: MlvDataTableColumn, direction: MlvSortDirection | null): 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 Returns a positive whole-number page size or the all-items sentinel. */
+    private _normalizePerPage;
+    /** @private Keeps only declared keys while preserving input-order uniqueness. */
+    private _knownPresentationKeys;
+    /** @private Clones only a known sortable sort state. */
+    private _normalizePresentationSort;
+    /** @private Emits one fresh normalized snapshot after a durable user gesture. */
+    private _emitPresentationStateChange;
+    /** @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: _angular_core.ɵɵFactoryDeclaration<MlvDataTable, never>;
+    static ɵcmp: _angular_core.ɵɵ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; }; "showSortMenu": { "alias": "showSortMenu"; "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"; "presentationStateChange": "presentationStateChange"; "loadMore": "loadMore"; "selectedRows": "selectedRowsChange"; "searchQuery": "searchQueryChange"; "activeFilters": "activeFiltersChange"; }, ["cellTemplates", "editCellTemplates", "noDataTemplate", "errorTemplate", "footerTemplate", "_toolbarActions"], never, true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}
+
+export { MlvDataTable, MlvDataTableCell, MlvDataTableEditCell, MlvDataTableError, MlvDataTableFooter, MlvDataTableNoData, MlvDataTableToolbarActions };
+export type { MlvColumnAlign, MlvColumnFilterConfig, MlvColumnResizeEvent, MlvColumnResizeSource, MlvColumnResponsive, MlvColumnToneFn, MlvColumnValueLabels, MlvDataTableCellContext, MlvDataTableColumn, MlvDataTableColumnGroup, MlvDataTableEditCellContext, MlvDataTableErrorContext, MlvDataTableFilterOperator, MlvDataTableFilterOption, MlvDataTablePresentationState, MlvEditEvent, MlvEditMode, MlvEditSaveEvent, MlvFilterDisplay, MlvLoadMoreEvent, MlvPaginationMode, MlvPinSide, MlvRowClickEvent, MlvSelectableMode, MlvSelectionChangeEvent };