@zeyos/zx 2.1.0 → 2.2.1

package/dist/types/components/table/table.d.ts

@@ -0,0 +1,872 @@
+import { Component } from '../../core/component.js';
+export type TableRow = Record<string, any>;
+export type TableSortDirection = 'asc' | 'desc';
+export type TableSelectionMode = false | 'single' | 'multi';
+export type TableEditMode = false | 'cell' | 'row';
+export type TableEditorType = 'text' | 'number' | 'select' | 'date' | 'checkbox' | 'textarea' | 'custom';
+export type TableEditorOption = {
+    value: unknown;
+    label: string;
+};
+export type TableEditorApi = {
+    /**
+     * Value the cell holds when the editor opens.
+     */
+    value: unknown;
+    /**
+     * Commits the edit with the given value.
+     */
+    commit: (value: unknown) => void;
+    /**
+     * Cancels the edit and restores the cell.
+     */
+    cancel: () => void;
+    /**
+     * Row being edited.
+     */
+    row: TableRow;
+    /**
+     * Column being edited.
+     */
+    column: TableColumn;
+};
+export type TableColumn = {
+    /**
+     * Row property and stable column identifier.
+     */
+    id: string;
+    /**
+     * Visible header label.
+     */
+    label: string;
+    /**
+     * Whether the header changes the active sort.
+     */
+    sortable?: boolean;
+    /**
+     * CSS width, `auto`, or an `fr` proportion. `fr` values are
+     * converted into proportional percentages on `<col>` elements and enable `table-layout: fixed`;
+     * this preserves a single aligned header/body table without measuring layout in JavaScript.
+     */
+    width?: string;
+    /**
+     * Cell alignment.
+     */
+    align?: 'start' | 'center' | 'end' | 'left' | 'right';
+    /**
+     * Cell renderer. Non-Node results are inserted as text.
+     */
+    render?: (row: TableRow, rowIndex: number) => Node | string | number | null | undefined;
+    /**
+     * Sort-value accessor.
+     */
+    sortValue?: (row: TableRow) => unknown;
+    /**
+     * Header tooltip.
+     */
+    headerTitle?: string;
+    /**
+     * While stacked, whether this column becomes a labelled line.
+     * `false` keeps it in the card's headline — the identifying columns usually want that.
+     */
+    popin?: boolean;
+    /**
+     * Editor for this column while the table runs with `editMode`. `true` means `'text'`; a function is
+     * evaluated per row so individual rows stay read-only.
+     */
+    editable?: boolean | TableEditorType | ((row: TableRow) => boolean | TableEditorType);
+    /**
+     * Choices for an `'select'` editor: `[{value, label}]`, a `{value: label}` map, or a row callback.
+     */
+    options?: TableEditorOption[] | Record<string, string> | ((row: TableRow) => TableEditorOption[] | Record<string, string>);
+    /**
+     * Options forwarded to the underlying editor
+     * component (NumberField, Select, Datebox, Toggle) or to the generated `<input>`/`<textarea>`.
+     */
+    editorProps?: Record<string, unknown>;
+    /**
+     * Fully custom editor. Wins over `editable`, except that a per-row `editable` function returning
+     * `false` still marks the cell read-only. A returned Zx component is destroyed with the edit.
+     */
+    editor?: (row: TableRow, api: TableEditorApi) => Node | {
+        toElement: () => Node;
+        destroy?: () => void;
+    };
+    /**
+     * Converts the editor's raw output into
+     * the value written back into the row.
+     */
+    parse?: (raw: unknown, row: TableRow) => unknown;
+    /**
+     * Renders the value as the initial
+     * text of a `'text'` or `'textarea'` editor.
+     */
+    format?: (value: unknown, row: TableRow) => string;
+    /**
+     * Commit guard. A returned
+     * string marks the cell invalid, shows the message, and refuses the commit.
+     */
+    validate?: (value: unknown, row: TableRow) => true | string;
+};
+export type TableOptions = {
+    /**
+     * Column definitions.
+     */
+    columns?: TableColumn[];
+    /**
+     * Initial rows.
+     */
+    data?: TableRow[];
+    /**
+     * Row id accessor.
+     */
+    rowId?: string | ((row: TableRow) => unknown);
+    /**
+     * Initial sort.
+     */
+    sort?: {
+        id: string;
+        dir: TableSortDirection;
+    } | null;
+    /**
+     * Whether sorting reorders local rows.
+     */
+    sortMode?: 'local' | 'server';
+    /**
+     * Row selection mode.
+     */
+    selectable?: TableSelectionMode;
+    /**
+     * Whether column headers stick while scrolling.
+     */
+    stickyHeader?: boolean;
+    /**
+     * Number of rows to render at first, with a control that
+     * appends the next batch on demand. A result set an ERP query returns happily — tens of thousands
+     * of rows — costs more to lay out than anyone will ever scroll through.
+     */
+    growing?: false | number;
+    /**
+     * Width below which each row stacks into a
+     * card of label/value pairs instead of scrolling sideways. Measured on the table's own container,
+     * not the viewport, so a table inside a split pane stacks when *it* is narrow.
+     */
+    responsive?: false | 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * Scroll-region height in pixels or CSS units.
+     */
+    height?: number | string | null;
+    /**
+     * What to show when there are no
+     * rows; null resolves `table.empty`. A Node — an `emptyState()` with an action in it, say — is
+     * placed as given, and a function is called on each render, which is what to use when the
+     * placeholder holds live controls.
+     */
+    emptyText?: string | Node | (() => Node | string) | null;
+    /**
+     * Additional row class callback.
+     */
+    rowClass?: ((row: TableRow) => string) | null;
+    /**
+     * Whether alternate rows use the zebra background.
+     */
+    zebra?: boolean;
+    /**
+     * Inline editing mode. `'cell'` edits one cell, `'row'`
+     * opens every editable cell of the row together and commits them as a unit. Editing is completely
+     * inert while this is `false`.
+     */
+    editMode?: TableEditMode;
+    onrowclick?: (event: CustomEvent<TableRowClickDetail>) => void;
+    onrowdblclick?: (event: CustomEvent<TableRowClickDetail>) => void;
+    onsort?: (event: CustomEvent<TableSortDetail>) => void;
+    onselectionchange?: (event: CustomEvent<TableSelectionDetail>) => void;
+    ondatachange?: (event: CustomEvent<TableDataDetail>) => void;
+    /**
+     * Fired when the
+     * table crosses its `responsive` width in either direction.
+     */
+    onstackedchange?: (event: CustomEvent<{
+        stacked: boolean;
+    }>) => void;
+    /**
+     * Fired after
+     * more rows are rendered.
+     */
+    ongrow?: (event: CustomEvent<{
+        rendered: number;
+        total: number;
+    }>) => void;
+    oneditstart?: (event: CustomEvent<TableEditStartDetail>) => void;
+    oneditcommit?: (event: CustomEvent<TableEditCommitDetail>) => void;
+    oneditcancel?: (event: CustomEvent<TableEditCancelDetail>) => void;
+    oneditinvalid?: (event: CustomEvent<TableEditInvalidDetail>) => void;
+};
+export type TableRowClickDetail = {
+    row: TableRow;
+    id: unknown;
+    index: number;
+    event: Event;
+};
+export type TableSortDetail = {
+    id: string;
+    dir: TableSortDirection;
+};
+export type TableSelectionDetail = {
+    rows: TableRow[];
+    ids: unknown[];
+};
+export type TableDataDetail = {
+    rows: TableRow[];
+};
+export type TableEditStartDetail = {
+    /**
+     * Row being edited.
+     */
+    row: TableRow;
+    /**
+     * Row id.
+     */
+    id: unknown;
+    /**
+     * Focused column.
+     */
+    column: TableColumn | null;
+    /**
+     * Focused column id.
+     */
+    columnId: string;
+    /**
+     * Value the editor opened with.
+     */
+    value: unknown;
+};
+export type TableEditCommitDetail = {
+    /**
+     * Row as it is before the commit.
+     */
+    row: TableRow;
+    /**
+     * Row id.
+     */
+    id: unknown;
+    /**
+     * Focused column.
+     */
+    column: TableColumn | null;
+    /**
+     * Focused column id.
+     */
+    columnId: string;
+    /**
+     * Committed value of the focused column.
+     */
+    value: unknown;
+    /**
+     * Previous value of the focused column.
+     */
+    previous: unknown;
+    /**
+     * Every changed cell of the row, keyed by column id.
+     */
+    changes: Record<string, unknown>;
+};
+export type TableEditCancelDetail = {
+    /**
+     * Row that was being edited.
+     */
+    row: TableRow;
+    /**
+     * Row id.
+     */
+    id: unknown;
+    /**
+     * Focused column.
+     */
+    column: TableColumn | null;
+    /**
+     * Focused column id.
+     */
+    columnId: string;
+};
+export type TableEditInvalidDetail = {
+    /**
+     * Row being edited.
+     */
+    row: TableRow;
+    /**
+     * Row id.
+     */
+    id: unknown;
+    /**
+     * Rejected column.
+     */
+    column: TableColumn | null;
+    /**
+     * Rejected column id.
+     */
+    columnId: string;
+    /**
+     * Rejected value.
+     */
+    value: unknown;
+    /**
+     * Validation message.
+     */
+    message: string;
+};
+export type TableEditorEntry = {
+    /**
+     * Edited column.
+     */
+    column: TableColumn;
+    /**
+     * Resolved editor type.
+     */
+    type: TableEditorType;
+    /**
+     * Edited cell.
+     */
+    td: HTMLTableCellElement;
+    /**
+     * Element the editor lives in.
+     */
+    host: HTMLElement;
+    /**
+     * Focusable control inside the editor.
+     */
+    control: HTMLElement | null;
+    /**
+     * Zx component instance, when the editor uses one.
+     */
+    component: {
+        destroy: () => void;
+    } | null;
+    /**
+     * Reads the editor's current value.
+     */
+    read: () => unknown;
+    /**
+     * Destroys the editor and removes its DOM.
+     */
+    destroy: () => void;
+};
+/**
+ * Semantic, sortable data table with optional single or checkbox-based multi-selection and
+ * opt-in inline cell or row editing.
+ * @fires Table#rowclick
+ * @fires Table#rowdblclick
+ * @fires Table#sort
+ * @fires Table#selectionchange
+ * @fires Table#datachange
+ * @fires Table#editstart
+ * @fires Table#editcommit
+ * @fires Table#editcancel
+ * @fires Table#editinvalid
+ * @extends {Component<TableOptions>}
+ */
+export declare class Table extends Component<TableOptions> {
+    _originalChildren: ChildNode[];
+    _columns: {
+        id: string;
+        label: string;
+        sortable?: boolean;
+        width?: string;
+        align?: 'start' | 'center' | 'end' | 'left' | 'right';
+        render?: (row: TableRow, rowIndex: number) => Node | string | number | null | undefined;
+        sortValue?: (row: TableRow) => unknown;
+        headerTitle?: string;
+        popin?: boolean;
+        editable?: boolean | TableEditorType | ((row: TableRow) => boolean | TableEditorType);
+        options?: TableEditorOption[] | Record<string, string> | ((row: TableRow) => TableEditorOption[] | Record<string, string>);
+        editorProps?: Record<string, unknown>;
+        editor?: (row: TableRow, api: TableEditorApi) => Node | {
+            toElement: () => Node;
+            destroy?: () => void;
+        };
+        parse?: (raw: unknown, row: TableRow) => unknown;
+        format?: (value: unknown, row: TableRow) => string;
+        validate?: (value: unknown, row: TableRow) => true | string;
+    }[];
+    _data: any[] | TableRow[];
+    _selected: Set<any>;
+    _selectionAnchorId: any;
+    _sort: any;
+    _rowMeta: WeakMap<object, any>;
+    _rowElements: Map<any, any>;
+    _restored: boolean;
+    _editMode: TableEditMode;
+    _edit: {
+        id: unknown;
+        columnId: string;
+        row: any;
+        cells: Map<string, TableEditorEntry>;
+        tr: any;
+    };
+    _editMessage: HTMLElement;
+    _stacked: any;
+    _width: import("../../core/breakpoint.js").BreakpointController;
+    _growStep: number;
+    _rendered: number;
+    _more: HTMLElement;
+    _rovingKey: {
+        id: unknown;
+        columnId: string;
+    };
+    _rovingCell: any;
+    _rovingMatched: boolean;
+    _table: HTMLElement;
+    _colgroup: HTMLElement;
+    _thead: HTMLElement;
+    _tbody: HTMLElement;
+    _scroll: HTMLElement;
+    _selectAll: HTMLElement;
+    _headers: Map<any, any>;
+    static cssName: string;
+    /** @type {TableOptions} */
+    static defaults: TableOptions;
+    /**
+     * Creates a table around a target or creates a new root when target is null.
+     * @param {Element|string|null} target Existing root, selector, or null.
+     * @param {TableOptions} [options={}] Table options.
+     */
+    constructor(target: Element | string | null, options?: TableOptions);
+    /** @returns {HTMLElement} Table root. */
+    render(): HTMLElement;
+    /**
+     * Toggles a loading state. While loading, the body is dimmed, an indeterminate progress bar is
+     * shown, and `aria-busy` is set — a lightweight take on the busy/skeleton pattern used by
+     * enterprise tables (SAP UI5, Salesforce SLDS). Call `setLoading(false)` (or `setData`) when done.
+     * @param {boolean} [loading=true] Whether the table is loading.
+     * @returns {this}
+     */
+    setLoading(loading?: boolean): this;
+    /**
+     * Replaces all rows.
+     * @param {TableRow[]} rows New rows.
+     * @returns {this}
+     * @fires Table#datachange
+     * @fires Table#editcancel
+     */
+    setData(rows: TableRow[]): this;
+    /**
+     * Appends rows to the current data.
+     * @param {TableRow[]} rows Rows to append.
+     * @returns {this}
+     * @fires Table#datachange
+     * @fires Table#editcancel
+     */
+    addData(rows: TableRow[]): this;
+    /**
+     * Replaces the row identified by its current id.
+     * @param {unknown} id Existing row id.
+     * @param {TableRow} row Replacement row.
+     * @returns {this}
+     * @fires Table#datachange
+     * @fires Table#editcancel
+     */
+    updateRow(id: unknown, row: TableRow): this;
+    /**
+     * Removes the row with the given id.
+     * @param {unknown} id Row id.
+     * @returns {this}
+     * @fires Table#selectionchange
+     * @fires Table#datachange
+     * @fires Table#editcancel
+     */
+    removeRow(id: unknown): this;
+    /**
+     * Returns a row by id.
+     * @param {unknown} id Row id.
+     * @returns {TableRow|null} Matching row or null.
+     */
+    getRow(id: unknown): TableRow | null;
+    /** @returns {TableRow[]} Shallow copy of current rows in display order. */
+    getData(): TableRow[];
+    /**
+     * Removes all rows.
+     * @returns {this}
+     * @fires Table#selectionchange
+     * @fires Table#datachange
+     * @fires Table#editcancel
+     */
+    empty(): this;
+    /**
+     * Activates a column sort. Local mode stably reorders data; server mode only updates the
+     * header state and emits the request event.
+     * @param {string} id Column id.
+     * @param {TableSortDirection} [dir] Direction; omitted toggles the current column.
+     * @param {{silent?: boolean}} [options={}] Event options.
+     * @returns {this}
+     * @fires Table#sort
+     * @fires Table#editcancel
+     */
+    setSort(id: string, dir?: TableSortDirection, options?: {
+        silent?: boolean;
+    }): this;
+    /** @returns {TableRow[]} Selected rows in current display order. */
+    getSelection(): TableRow[];
+    /**
+     * Replaces selected ids, ignoring ids absent from the current data.
+     * @param {unknown[]} ids Row ids.
+     * @returns {this}
+     * @fires Table#selectionchange
+     */
+    setSelection(ids: unknown[]): this;
+    /**
+     * Clears all selected rows.
+     * @returns {this}
+     * @fires Table#selectionchange
+     */
+    clearSelection(): this;
+    /**
+     * Opens the editor for a cell. No-op unless the table runs with `editMode` and the column
+     * resolves to an editable type for that row. In `'row'` mode every editable cell of the row is
+     * opened and `columnId` only decides which editor receives focus. Any other open edit is
+     * committed first.
+     * @param {unknown} rowId Row id.
+     * @param {string} columnId Column id.
+     * @returns {this}
+     * @fires Table#editstart
+     */
+    startEdit(rowId: unknown, columnId: string): this;
+    /**
+     * Commits the open edit. Validation runs first: the first column whose `validate` rejects marks
+     * its cell invalid, emits `editinvalid`, and leaves the editor open. A listener may
+     * `preventDefault()` the `editcommit` event — e.g. while a server round-trip is pending — which
+     * also keeps the editor open. Otherwise every changed cell is written back through `updateRow()`,
+     * so `datachange` fires exactly as it does for a programmatic row update.
+     * @returns {this}
+     * @fires Table#editcommit
+     * @fires Table#editinvalid
+     * @fires Table#datachange
+     */
+    commitEdit(): this;
+    /**
+     * Closes the open edit without writing anything back and returns focus to the cell.
+     * @returns {this}
+     * @fires Table#editcancel
+     */
+    cancelEdit(): this;
+    /** @returns {boolean} Whether a cell or row is currently open for editing. */
+    isEditing(): boolean;
+    /** @returns {{id: unknown, columnId: string}|null} Row id and focused column id, or null. */
+    getEditing(): {
+        id: unknown;
+        columnId: string;
+    } | null;
+    /**
+     * The rows currently rendered — all of them unless `growing` is on.
+     * @returns {TableRow[]}
+     */
+    _visibleData(): TableRow[];
+    /**
+     * Renders the next batch of rows.
+     * @param {number} [count] How many to add; defaults to the configured batch size.
+     * @returns {this}
+     * @fires Table#grow
+     */
+    growBy(count?: number): this;
+    /**
+     * Renders every remaining row.
+     * @returns {this}
+     * @fires Table#grow
+     */
+    showAll(): this;
+    /**
+     * How many rows are currently rendered.
+     * @returns {number}
+     */
+    getRenderedCount(): number;
+    /**
+     * Keeps the "show more" control in step with what is rendered.
+     *
+     * The control sits outside the table rather than in a `<tfoot>` row spanning every column: it is
+     * a command, not data, and a button inside the grid would be reachable by the row navigation
+     * keys as though it were a cell.
+     * @returns {void}
+     */
+    _syncGrowing(): void;
+    /**
+     * Resolves a localized message, falling back to a built-in template.
+     * @param {string} key Message key.
+     * @param {string} fallback Template used when the host has no translation.
+     * @param {unknown[]} args Positional interpolation values.
+     * @returns {string}
+     */
+    _message(key: string, fallback: string, args: unknown[]): string;
+    /**
+     * Watches the table's own width and stacks the rows below `responsive`.
+     *
+     * The width comes from `onBreakpoint` observing this element rather than the window, which is the
+     * whole point of the option: a table inside a split pane or a modal has no idea how wide the
+     * viewport is, and a media query would stack it on a phone while leaving it unreadable in a
+     * 320px pane on a desktop.
+     * @returns {void}
+     */
+    _watchWidth(): void;
+    /**
+     * Enters or leaves stacked mode.
+     * @param {boolean} stacked Whether rows should stack.
+     * @returns {void}
+     * @fires Table#stackedchange
+     */
+    _setStacked(stacked: boolean): void;
+    /**
+     * States the table roles explicitly while stacked, and removes them again on the way out.
+     *
+     * Stacking works by changing `display` on the table elements, and a table whose display is not
+     * `table` loses its implicit ARIA roles — leaving a screen reader with a pile of generic blocks
+     * where a table used to be. The roles are only asserted while the layout has taken them away.
+     * @param {boolean} stacked Whether the roles should be present.
+     * @returns {void}
+     */
+    _applyStackedRoles(stacked: boolean): void;
+    /**
+     * Reports whether the rows are currently stacked.
+     * @returns {boolean}
+     */
+    isStacked(): boolean;
+    /** Restores an enhanced target and releases all component listeners. @returns {void} */
+    destroy(): void;
+    /** @returns {void} */
+    _renderColumns(): void;
+    /** @returns {void} */
+    _renderHeader(): void;
+    /** @returns {void} @fires Table#editcancel */
+    _renderBody(): void;
+    /**
+     * What to put in the empty row.
+     *
+     * An empty table is a screen in its own right — the place to say why there is nothing and what to
+     * do about it — so this takes a node as readily as a string. A function is re-called on every
+     * render, which matters when the placeholder contains a button: reusing one node would move the
+     * same element between renders and quietly share its listeners.
+     * @returns {Node|string}
+     */
+    _emptyContent(): Node | string;
+    /** @param {TableRow} row @param {number} index @returns {HTMLTableRowElement} */
+    _createRow(row: TableRow, index: number): HTMLTableRowElement;
+    /**
+     * Fills a cell with the column's rendered value, replacing anything already in it.
+     * @param {HTMLTableCellElement} cell Target cell.
+     * @param {TableColumn} column Column definition.
+     * @param {TableRow} row Row data.
+     * @param {number} index Row index.
+     * @returns {void}
+     */
+    _renderCellContent(cell: HTMLTableCellElement, column: TableColumn, row: TableRow, index: number): void;
+    /** @param {MouseEvent} event @returns {void} */
+    _handleBodyClick(event: MouseEvent): void;
+    /** @param {MouseEvent} event @returns {void} @fires Table#editstart */
+    _handleBodyDoubleClick(event: MouseEvent): void;
+    /**
+     * Builds the editor for one cell and mounts it over the cell's content.
+     * @param {HTMLTableCellElement} td Cell to edit.
+     * @param {TableColumn} column Column definition.
+     * @param {TableRow} row Row being edited.
+     * @param {number} index Row index.
+     * @returns {TableEditorEntry|null} Editor entry, or null when the column is read-only.
+     */
+    _createEditor(td: HTMLTableCellElement, column: TableColumn, row: TableRow, index: number): TableEditorEntry | null;
+    /**
+     * Moves focus into one of the open editors.
+     * @param {string} columnId Column id.
+     * @returns {void}
+     */
+    _focusEditor(columnId: string): void;
+    /**
+     * Moves focus back onto a cell.
+     * @param {unknown} id Row id.
+     * @param {string} columnId Column id.
+     * @returns {void}
+     */
+    _focusCell(id: unknown, columnId: string): void;
+    /** Destroys every open editor and restores the cells they covered. @returns {void} */
+    _teardownEdit(): void;
+    /**
+     * Cancels the open edit, optionally returning focus to its cell.
+     * @param {{focus?: boolean}} [options={}] Whether focus returns to the edited cell.
+     * @returns {void}
+     * @fires Table#editcancel
+     */
+    _abortEdit({ focus }?: {
+        focus?: boolean;
+    }): void;
+    /** @returns {boolean} Whether focus currently sits inside this table. */
+    _editHasFocus(): boolean;
+    /**
+     * Marks one edited cell invalid and announces the message.
+     * @param {string} columnId Rejected column id.
+     * @param {string} message Validation message.
+     * @returns {void}
+     */
+    _markInvalid(columnId: string, message: string): void;
+    /** Clears the invalid marks and the validation message. @returns {void} */
+    _clearInvalid(): void;
+    /**
+     * Handles Enter/F2 on a focused cell and Escape/Enter/Tab inside an open editor.
+     * @param {KeyboardEvent} event Keydown event.
+     * @returns {void}
+     */
+    _handleEditKeydown(event: KeyboardEvent): void;
+    /**
+     * Commits the current editor and moves the edit one editable cell forward or backward.
+     * @param {KeyboardEvent} event Tab keydown.
+     * @returns {void}
+     */
+    _moveEdit(event: KeyboardEvent): void;
+    /**
+     * Finds the next editable cell, wrapping from the end of a row into the next row.
+     * @param {number} rowIndex Row index to start from.
+     * @param {string} columnId Column id to start from.
+     * @param {number} direction `1` forward, `-1` backward.
+     * @returns {{id: unknown, columnId: string, index: number}|null} Next cell, or null at the end.
+     */
+    _nextEditableCell(rowIndex: number, columnId: string, direction: number): {
+        id: unknown;
+        columnId: string;
+        index: number;
+    } | null;
+    /** @param {Event} event @returns {void} */
+    _handleEditFocusIn(event: Event): void;
+    /** @param {Event} event @returns {void} @fires Table#editcommit */
+    _handleDocumentPointerDown(event: Event): void;
+    /**
+     * Keeps exactly one editable cell in the tab order, preferring the last focused one.
+     * @param {HTMLTableCellElement} cell Newly rendered editable cell.
+     * @param {unknown} id Row id.
+     * @param {string} columnId Column id.
+     * @returns {void}
+     */
+    _offerRovingCell(cell: HTMLTableCellElement, id: unknown, columnId: string): void;
+    /** @param {HTMLTableCellElement} cell @param {unknown} id @param {string} columnId @returns {void} */
+    _setRovingCell(cell: HTMLTableCellElement, id: unknown, columnId: string): void;
+    /**
+     * Resolves a message key with an English fallback for hosts without a translator.
+     * @param {string} key Message key.
+     * @param {string} fallback Text used when the key is untranslated.
+     * @returns {string}
+     */
+    _msgOr(key: string, fallback: string): string;
+    /** @param {{row: TableRow, id: unknown, index: number}} meta @param {boolean} checked @param {boolean} shiftKey @returns {void} */
+    _toggleMultiSelection(meta: {
+        row: TableRow;
+        id: unknown;
+        index: number;
+    }, checked: boolean, shiftKey: boolean): void;
+    /** @returns {void} */
+    _syncSelection(): void;
+    /** @returns {void} */
+    _syncSelectAll(): void;
+    /** @returns {void} */
+    _syncSortHeader(): void;
+    /** @returns {void} */
+    _sortData(): void;
+    /** @returns {boolean} Whether selection changed. */
+    _pruneSelection(): boolean;
+    /** @param {TableRow} row @returns {unknown} */
+    _idFor(row: TableRow): unknown;
+    /** @returns {void} @fires Table#selectionchange */
+    _emitSelectionChange(): void;
+    /** @returns {void} @fires Table#datachange */
+    _emitDataChange(): void;
+}
+/**
+ * Row activation event.
+ * @event Table#rowclick
+ * @type {CustomEvent<TableRowClickDetail>}
+ */
+/**
+ * Row double-activation event.
+ * @event Table#rowdblclick
+ * @type {CustomEvent<TableRowClickDetail>}
+ */
+/** @event Table#sort @type {CustomEvent<TableSortDetail>} */
+/** @event Table#selectionchange @type {CustomEvent<TableSelectionDetail>} */
+/** @event Table#datachange @type {CustomEvent<TableDataDetail>} */
+/**
+ * Editor opened for a cell (or, in row mode, for the row).
+ * @event Table#editstart
+ * @type {CustomEvent<TableEditStartDetail>}
+ */
+/**
+ * Values are about to be written back. Cancelable: `preventDefault()` keeps the editor open, which
+ * lets a server round-trip reject the change.
+ * @event Table#editcommit
+ * @type {CustomEvent<TableEditCommitDetail>}
+ */
+/**
+ * Editing ended without writing anything back — Escape, `cancelEdit()`, or a data refresh
+ * (`setData`, `setSort`, …) that replaced the edited rows.
+ * @event Table#editcancel
+ * @type {CustomEvent<TableEditCancelDetail>}
+ */
+/**
+ * A column's `validate` rejected the commit.
+ * @event Table#editinvalid
+ * @type {CustomEvent<TableEditInvalidDetail>}
+ */
+/**
+ * Resolves the editor type of a column for one row.
+ *
+ * `column.editor` wins over `column.editable`, except that a per-row `editable` function returning
+ * `false` still marks the cell read-only. `editable: true` means `'text'`; unknown type names are
+ * treated as not editable.
+ * @param {TableColumn} column Column definition.
+ * @param {TableRow} row Row the cell belongs to.
+ * @returns {TableEditorType|false} Editor type, or false when the cell is read-only.
+ */
+export declare function resolveEditable(column: TableColumn, row: TableRow): TableEditorType | false;
+/**
+ * Normalizes `column.options` into `[{value, label}]`. Object maps always yield string values,
+ * because object keys are strings; use the array form to keep other value types.
+ * @param {TableEditorOption[]|Record<string, string>|((row: TableRow) => unknown)|undefined} source Option source.
+ * @param {TableRow} row Row the options are resolved for.
+ * @returns {TableEditorOption[]} Normalized options.
+ */
+export declare function normalizeEditorOptions(source: TableEditorOption[] | Record<string, string> | ((row: TableRow) => unknown) | undefined, row: TableRow): TableEditorOption[];
+/**
+ * Renders a value as the initial text of a text or textarea editor.
+ * @param {TableColumn} column Column definition.
+ * @param {unknown} value Cell value.
+ * @param {TableRow} row Row the cell belongs to.
+ * @returns {string} Editor text.
+ */
+export declare function formatCellValue(column: TableColumn, value: unknown, row: TableRow): string;
+/**
+ * Converts an editor's raw output into the value written back into the row.
+ * @param {TableColumn} column Column definition.
+ * @param {unknown} raw Editor output.
+ * @param {TableRow} row Row the cell belongs to.
+ * @returns {unknown} Value for the row.
+ */
+export declare function parseCellValue(column: TableColumn, raw: unknown, row: TableRow): unknown;
+/**
+ * Compares two cell values, treating equal-timestamp dates as unchanged.
+ * @param {unknown} left First value.
+ * @param {unknown} right Second value.
+ * @returns {boolean} Whether the values are equal.
+ */
+export declare function valuesEqual(left: unknown, right: unknown): boolean;
+/**
+ * Diffs edited values against a row and returns only what actually changed. This is the `changes`
+ * map carried by `editcommit`; in row mode it holds every changed cell of the row.
+ * @param {TableRow} row Row before the commit.
+ * @param {Record<string, unknown>} values Edited values keyed by column id.
+ * @returns {Record<string, unknown>} Changed values keyed by column id.
+ */
+export declare function diffChanges(row: TableRow, values: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Runs the columns' `validate` callbacks in column order and stops at the first rejection, so a
+ * later validator never runs once one has failed.
+ * @param {Record<string, unknown>} values Edited values keyed by column id.
+ * @param {TableColumn[]} columns Columns to validate, in order.
+ * @param {TableRow} row Row being edited.
+ * @param {string} [fallbackMessage='Invalid value'] Message used when a validator returns `false`.
+ * @returns {{columnId: string, message: string}|null} First rejection, or null when all pass.
+ */
+export declare function firstValidationError(values: Record<string, unknown>, columns: TableColumn[], row: TableRow, fallbackMessage?: string): {
+    columnId: string;
+    message: string;
+} | null;