@luzmo/lucero 2.4.2 → 2.5.0

package/components/table/controllers/table-layout.d.ts

@@ -0,0 +1,55 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { ElementSize } from '../../../utils/sized-mixin';
+import { TableColumnLayout } from '../table-columns';
+import type { LuzmoTableHeadCell } from '../table-head-cell';
+import { TableModel } from '../table-model';
+import { TableColumn, TableItem, TableLabels, TableRenderDetails, TableSelects } from '../types';
+export interface TableLayoutHost extends ReactiveControllerHost, HTMLElement {
+    columns: TableColumn[];
+    columnWidths: Record<string, number>;
+    items?: TableItem[];
+    renderDetails?: TableRenderDetails;
+    selects?: TableSelects;
+    emphasized: boolean;
+    size: ElementSize;
+    labels: TableLabels;
+    selectAllLabel?: string;
+}
+export interface TableLayoutOptions {
+    model: TableModel;
+    owns: (event: Event) => boolean;
+}
+/**
+ * Column tracks and the header/body presentation pass. Subscribes to body
+ * scroll so the header stays aligned, and tears that listener down on
+ * disconnect.
+ */
+export declare class TableLayoutController implements ReactiveController {
+    private readonly host;
+    private readonly options;
+    private bodyObserver?;
+    private observedBody?;
+    constructor(host: TableLayoutHost, options: TableLayoutOptions);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    hostUpdated(): void;
+    hasExpansion(): boolean;
+    layouts(): TableColumnLayout[];
+    headCells(): LuzmoTableHeadCell[];
+    applyGridMetrics(): void;
+    syncPresentation(): void;
+    syncHeadTabStops(): void;
+    private handleBodyScroll;
+    private syncHead;
+    private watchBodyScrollbar;
+    private syncHeadScroll;
+    private syncColumns;
+    private syncDeclarativeRows;
+    private syncGridColumns;
+    private isDataMode;
+    private slottedHead;
+    private head;
+    private body;
+    private declarativeRows;
+    private rows;
+}

package/components/table/controllers/table-row-expansion.d.ts

@@ -0,0 +1,45 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import type { LuzmoTableRowDetails } from '../table-row-details';
+import type { LuzmoTableRow } from '../table-row';
+import { TableLabels } from '../types';
+export declare const tableDetailsClosingSymbol: unique symbol;
+type ExpansionUpdateHost = ReactiveControllerHost & {
+    requestUpdate(name?: PropertyKey, oldValue?: unknown): void;
+};
+export interface TableRowExpansionHost extends ExpansionUpdateHost, HTMLElement {
+    expanded: string[];
+    labels: TableLabels;
+    selectAllLabel?: string;
+    items?: readonly unknown[];
+}
+export interface TableRowExpansionOptions {
+    owns: (event: Event) => boolean;
+    focusDisclosure: (element: HTMLElement) => void;
+}
+export declare const detailsForRow: (row: HTMLElement) => LuzmoTableRowDetails | null;
+/**
+ * Row details open and close. Owns the closing-animation set, the cancelable
+ * toggle event, and the collapsed-event subscription.
+ */
+export declare class TableRowExpansionController implements ReactiveController {
+    private readonly host;
+    private readonly options;
+    private closingDetails;
+    constructor(host: TableRowExpansionHost, options: TableRowExpansionOptions);
+    get closing(): ReadonlySet<string>;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /** Drops in-progress closing rows when the table changes mode. */
+    clear(): void;
+    toggle(row: LuzmoTableRow): void;
+    collapseFromPath(path: EventTarget[]): void;
+    private handleDetailsCollapsed;
+    private setClosing;
+    private dispatchToggle;
+    private expandLabel;
+    private rowByValue;
+    private isDataMode;
+    private declarativeRows;
+    private rows;
+}
+export {};

package/components/table/controllers/table-virtualizer.d.ts

@@ -0,0 +1,42 @@
+import { VirtualItem } from '@tanstack/virtual-core';
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+import { TableRangeChangedDetail } from '../types';
+export declare const tableVirtualRangeUpdatedSymbol: unique symbol;
+type RangeUpdateHost = ReactiveControllerHost & {
+    requestUpdate(name?: PropertyKey, oldValue?: unknown): void;
+};
+export interface TableVirtualizerOptions {
+    getScrollElement: () => HTMLElement | null;
+    getRowElements: () => HTMLElement[];
+    /** Whether a mounted row element has rendered and has its final height. */
+    isRendered: (element: HTMLElement) => boolean;
+    onRangeChanged: (detail: TableRangeChangedDetail) => void;
+}
+/**
+ * Mounts only the visible window of data-mode rows. The scroll element is the
+ * generated `luzmo-table-body`; rows are measured through `data-index`.
+ */
+export declare class TableVirtualizerController implements ReactiveController {
+    private readonly host;
+    private readonly options;
+    private virtualizer?;
+    private cleanup?;
+    private connected;
+    private keys;
+    private range?;
+    private estimatedSize;
+    constructor(host: RangeUpdateHost, options: TableVirtualizerOptions);
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    /** Updates the ordered row keys and returns the rows to mount. */
+    sync(keys: string[]): VirtualItem[];
+    get totalSize(): number;
+    scrollToIndex(index: number): void;
+    hostConnected(): void;
+    hostUpdated(): void;
+    hostDisconnected(): void;
+    private syncEstimate;
+    private createOptions;
+    private reportRange;
+}
+export {};

package/components/table/index.cjs

@@ -0,0 +1,18 @@
+/*! * Lucero - The design system for Luzmo.
+ * 
+ * Copyright © 2026 Luzmo
+ * All rights reserved.
+ * Lucero (“Luzmo Design System”) must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account to use Lucero.
+ * This license terminates automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`}),require("../tokens.cjs");const e=require("../table-CHrAaVU1.cjs");exports.DEFAULT_TABLE_LABELS=e.u,exports.LuzmoTable=e.c,exports.LuzmoTableBody=e.s,exports.LuzmoTableCell=e.o,exports.LuzmoTableCheckboxCell=e.a,exports.LuzmoTableDisclosureCell=e.n,exports.LuzmoTableHead=e.i,exports.LuzmoTableHeadCell=e.r,exports.LuzmoTableRow=e.t,exports.LuzmoTableRowDetails=e.l;

package/components/table/index.d.ts

@@ -0,0 +1,32 @@
+import { LuzmoTable } from './table';
+import { LuzmoTableBody } from './table-body';
+import { LuzmoTableCell } from './table-cell';
+import { LuzmoTableCheckboxCell } from './table-checkbox-cell';
+import { LuzmoTableHead } from './table-head';
+import { LuzmoTableHeadCell } from './table-head-cell';
+import { LuzmoTableDisclosureCell } from './table-disclosure-cell';
+import { LuzmoTableRow } from './table-row';
+import { LuzmoTableRowDetails } from './table-row-details';
+declare global {
+    interface HTMLElementTagNameMap {
+        'luzmo-table': LuzmoTable & HTMLElement;
+        'luzmo-table-head': LuzmoTableHead & HTMLElement;
+        'luzmo-table-head-cell': LuzmoTableHeadCell & HTMLElement;
+        'luzmo-table-body': LuzmoTableBody & HTMLElement;
+        'luzmo-table-row': LuzmoTableRow & HTMLElement;
+        'luzmo-table-cell': LuzmoTableCell & HTMLElement;
+        'luzmo-table-checkbox-cell': LuzmoTableCheckboxCell & HTMLElement;
+        'luzmo-table-disclosure-cell': LuzmoTableDisclosureCell & HTMLElement;
+        'luzmo-table-row-details': LuzmoTableRowDetails & HTMLElement;
+    }
+}
+export { LuzmoTable } from './table';
+export { LuzmoTableBody } from './table-body';
+export { LuzmoTableCell } from './table-cell';
+export { LuzmoTableCheckboxCell } from './table-checkbox-cell';
+export { LuzmoTableHead } from './table-head';
+export { LuzmoTableHeadCell } from './table-head-cell';
+export { LuzmoTableDisclosureCell } from './table-disclosure-cell';
+export { LuzmoTableRow } from './table-row';
+export { LuzmoTableRowDetails } from './table-row-details';
+export * from './types';

package/components/table/index.js

@@ -0,0 +1,20 @@
+/*! * Lucero - The design system for Luzmo.
+ * 
+ * Copyright © 2026 Luzmo
+ * All rights reserved.
+ * Lucero (“Luzmo Design System”) must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account to use Lucero.
+ * This license terminates automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+import "../tokens.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "../table-B75GjBhD.js";
+export { l as DEFAULT_TABLE_LABELS, t as LuzmoTable, s as LuzmoTableBody, a as LuzmoTableCell, e as LuzmoTableCheckboxCell, i as LuzmoTableDisclosureCell, n as LuzmoTableHead, o as LuzmoTableHeadCell, c as LuzmoTableRow, r as LuzmoTableRowDetails };

package/components/table/table-body.d.ts

@@ -0,0 +1,24 @@
+import { CSSResultArray, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+/**
+ * @element luzmo-table-body
+ *
+ * Becomes a tab stop while its rows overflow, so the scroll region can be
+ * reached from the keyboard.
+ *
+ * @slot - `luzmo-table-row` elements.
+ *
+ * @fires luzmo-table-body-scroll - The body scroll position changed.
+ */
+export declare class LuzmoTableBody extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    private resizeObserver?;
+    private mutationObserver?;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected render(): TemplateResult;
+    private _handleScroll;
+    private _syncTabStop;
+}

package/components/table/table-cell.d.ts

@@ -0,0 +1,27 @@
+import { CSSResultArray, PropertyValues, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+/**
+ * @element luzmo-table-cell
+ *
+ * @slot - Cell content.
+ *
+ * @attr line-clamp - Maximum number of lines before the cell truncates.
+ */
+export declare class LuzmoTableCell extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    /**
+     * Maximum number of lines before the cell truncates. Unset wraps.
+     * Overrides the column's `lineClamp`.
+     */
+    lineClamp: number | undefined;
+    /**
+     * Spans every column. Set on the single cell of an information row.
+     * @internal
+     */
+    spanAll: boolean;
+    /** @internal Column default used when `lineClamp` is unset. */
+    columnLineClamp: number | undefined;
+    protected willUpdate(changes: PropertyValues<this>): void;
+    protected render(): TemplateResult;
+}

package/components/table/table-checkbox-cell.d.ts

@@ -0,0 +1,41 @@
+import { CSSResultArray, nothing, PropertyValues, TemplateResult } from 'lit';
+import '../checkbox';
+import { LuzmoElement } from '../../utils/base';
+import type { ElementSize } from '../../utils/sized-mixin';
+/**
+ * @element luzmo-table-checkbox-cell
+ *
+ * Rendered by `luzmo-table-head` and `luzmo-table-row` while the table
+ * `selects`. Its `luzmo-checkbox` reports through the table's `change`
+ * event.
+ *
+ * @attr head-cell - Renders the select-all cell of the header row.
+ * @attr selects-single - Single selection: the cell leaves the accessibility tree and the tab order. The header renders no checkbox.
+ */
+export declare class LuzmoTableCheckboxCell extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    /**
+     * Whether this is the select-all cell of the header row.
+     */
+    headCell: boolean;
+    checked: boolean;
+    indeterminate: boolean;
+    disabled: boolean;
+    selectsSingle: boolean;
+    emphasized: boolean;
+    /**
+     * Accessible name of the checkbox.
+     */
+    label: string;
+    /**
+     * Checkbox size, mirrored from the table.
+     * @internal
+     */
+    size: ElementSize;
+    private checkbox?;
+    constructor();
+    protected render(): TemplateResult | typeof nothing;
+    protected willUpdate(changes: PropertyValues<this>): void;
+    private handleClick;
+}

package/components/table/table-columns.d.ts

@@ -0,0 +1,45 @@
+import { TableColumn } from './types';
+export interface TableColumnLayout {
+    id: string;
+    header: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    resizable?: boolean;
+    lineClamp?: number;
+}
+export declare const DEFAULT_COLUMN_MIN_WIDTH = 48;
+export declare const COLUMN_RESIZE_MAX_WIDTH = 10000;
+export declare const COLUMN_RESIZE_STEP = 16;
+export declare const COLUMN_RESIZE_PAGE_STEP = 64;
+export declare const definedNumber: (value: number | undefined) => number | undefined;
+export declare const detailsElementId: (value: string) => string;
+export declare const columnMinWidth: (column: TableColumnLayout) => number;
+export declare const columnMaxWidth: (column: TableColumnLayout) => number;
+export declare const clampColumnWidth: (width: number, column: TableColumnLayout) => number;
+export declare const columnTrack: (column: TableColumnLayout, resized: number | undefined) => string;
+export declare const gridTemplateColumns: (columns: TableColumnLayout[], widths: Record<string, number>, leading: {
+    selects: boolean;
+    expandable: boolean;
+}) => string;
+/**
+ * The narrowest the grid can get before its tracks overflow. The table
+ * scrolls horizontally below this width instead of squeezing fixed columns.
+ */
+export declare const gridMinInlineSize: (columns: TableColumnLayout[], widths: Record<string, number>, leading: {
+    selects: boolean;
+    expandable: boolean;
+}) => string;
+export declare const layoutFromColumn: (column: TableColumn) => TableColumnLayout;
+export type ColumnResizeAction = 'decrease' | 'increase' | 'min' | 'max';
+export interface ColumnResizeCommand {
+    action: ColumnResizeAction;
+    amount: number;
+}
+/**
+ * Keyboard resizing is logical: ArrowRight grows a column in LTR and shrinks
+ * it in RTL. Page keys follow that axis in larger steps. Home and End jump
+ * to the limits.
+ */
+export declare const columnResizeCommand: (code: string, isLTR: boolean) => ColumnResizeCommand | undefined;
+export declare const resizedWidth: (current: number, command: ColumnResizeCommand, column: TableColumnLayout) => number;

package/components/table/table-disclosure-cell.d.ts

@@ -0,0 +1,21 @@
+import { CSSResultArray, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+/**
+ * @element luzmo-table-disclosure-cell
+ *
+ * Rendered by `luzmo-table-row` for an expandable row. Activate it to expand
+ * or collapse that row.
+ *
+ * The button carries `aria-expanded`. The owning row carries `aria-controls`
+ * because that id lives outside this cell's shadow tree.
+ */
+export declare class LuzmoTableDisclosureCell extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    expanded: boolean;
+    /**
+     * Accessible name of the disclosure button.
+     */
+    label: string;
+    protected render(): TemplateResult;
+}

package/components/table/table-head-cell.d.ts

@@ -0,0 +1,77 @@
+import { CSSResultArray, PropertyValues, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+import { TableColumnLayout } from './table-columns';
+import { TableSortDirection } from './types';
+/**
+ * @element luzmo-table-head-cell
+ *
+ * @slot - Column header content.
+ *
+ * @fires luzmo-table-sorted - A sortable header was activated. `detail` is `{ sortKey, sortDirection }`. Cancel it in data mode to skip the client sort. Cancel it on this header to keep sibling sort directions unchanged.
+ *
+ * @attr sort-direction - Current sort direction, `asc` or `desc`.
+ * @attr sort-key - Item key the column sorts by.
+ * @attr column-id - Stable column identifier.
+ * @attr min-width - Minimum column width, in pixels.
+ * @attr max-width - Maximum column width, in pixels.
+ * @attr line-clamp - Maximum number of header lines before the text truncates.
+ */
+export declare class LuzmoTableHeadCell extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    /**
+     * Pressed state while Space is held on a sortable header.
+     */
+    active: boolean;
+    /**
+     * Whether activating the header sorts the table.
+     */
+    sortable: boolean;
+    /**
+     * Current sort direction. Unset when the column is not sorted.
+     */
+    sortDirection: TableSortDirection | undefined;
+    /**
+     * Item key the column sorts by. Sent as `sortKey` in `luzmo-table-sorted`.
+     */
+    sortKey: string;
+    /**
+     * Stable column identifier. Defaults to `sortKey`, then the column index.
+     */
+    columnId: string;
+    /**
+     * Fixed column width, in pixels.
+     */
+    width: number | undefined;
+    /**
+     * Minimum column width, in pixels.
+     */
+    minWidth: number | undefined;
+    /**
+     * Maximum column width, in pixels.
+     */
+    maxWidth: number | undefined;
+    /**
+     * Whether the header shows a resize handle.
+     */
+    resizable: boolean;
+    /**
+     * Maximum number of header lines before the text truncates. Unset wraps.
+     * Also the default clamp for the column's cells.
+     */
+    lineClamp: number | undefined;
+    /** @internal Measured or resized width announced by the resize handle. */
+    currentWidth: number;
+    /** @internal Accessible name of the resize handle. */
+    resizeLabel: string;
+    constructor();
+    /** @internal Layout values read by the table. */
+    toLayout(index: number): TableColumnLayout;
+    protected render(): TemplateResult;
+    protected updated(changes: PropertyValues<this>): void;
+    private _sort;
+    private handleClick;
+    private handleKeydown;
+    private handleKeyup;
+    private handleBlur;
+}

package/components/table/table-head.d.ts

@@ -0,0 +1,34 @@
+import { CSSResultArray, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+import type { ElementSize } from '../../utils/sized-mixin';
+import { TableSelects } from './types';
+/**
+ * @element luzmo-table-head
+ *
+ * @slot - `luzmo-table-head-cell` elements.
+ */
+export declare class LuzmoTableHead extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    /**
+     * Whether any row is selected. Mirrored from the table.
+     */
+    selected: boolean;
+    /** @internal */
+    selects: TableSelects | undefined;
+    /** @internal */
+    checked: boolean;
+    /** @internal */
+    indeterminate: boolean;
+    /** @internal */
+    emphasized: boolean;
+    /** @internal */
+    checkboxLabel: string;
+    /** @internal */
+    checkboxSize: ElementSize;
+    /** @internal */
+    expandable: boolean;
+    constructor();
+    protected render(): TemplateResult;
+    private handleSorted;
+}

package/components/table/table-model.d.ts

@@ -0,0 +1,56 @@
+import { TableItem, TableItemValue, TableLabels, TableSelects, TableSortDirection } from './types';
+export interface TableRecord<T extends TableItem = TableItem> {
+    item: T;
+    value: string;
+    /** Position in the source `items` array or in the slotted rows. */
+    index: number;
+    information: boolean;
+}
+export interface TableSort {
+    key: string;
+    direction: TableSortDirection;
+}
+export declare const isInformationItem: (item: TableItem) => boolean;
+export declare const toAriaSort: (direction?: TableSortDirection) => "ascending" | "descending" | "none";
+export declare const nextSortDirection: (direction?: TableSortDirection) => TableSortDirection;
+export declare const resolveTableLabels: (labels?: TableLabels, selectAllLabel?: string) => Required<TableLabels>;
+export declare const interpolate: (template: string, replacements: Record<string, string>) => string;
+export declare const parseJsonArray: (value: string | null) => unknown[] | undefined;
+export declare const createRecords: <T extends TableItem>(items: T[], itemValue?: TableItemValue<T>) => TableRecord<T>[];
+/**
+ * Wraps a headless TanStack table that owns sort order and row selection.
+ * The model never commits a selection itself: `toggle` and `toggleAll`
+ * return the next `selected` array so the element stays the single source
+ * of truth.
+ */
+export declare class TableModel<T extends TableItem = TableItem> {
+    selects?: TableSelects;
+    /** BCP 47 tag used to collate string values while sorting. */
+    locale?: string;
+    private records;
+    private sorting;
+    private manualSorting;
+    private rowSelection;
+    private selectedOrder;
+    private columns;
+    private pendingSelection?;
+    private collator?;
+    private collatorLocale?;
+    private readonly table;
+    setRecords(records: TableRecord<T>[]): void;
+    setSelected(values: string[]): void;
+    setSorting(sort?: TableSort, manual?: boolean): void;
+    get rows(): TableRecord<T>[];
+    isSelected(value: string): boolean;
+    get allSelected(): boolean;
+    get someSelected(): boolean;
+    /** Returns the next selection, or `undefined` when the row cannot be selected. */
+    toggle(value: string): string[] | undefined;
+    toggleAll(checked: boolean): string[];
+    private get selectableRecords();
+    private findRow;
+    private capture;
+    private compare;
+    private createSortColumn;
+    private sync;
+}

package/components/table/table-row-details.d.ts

@@ -0,0 +1,29 @@
+import { CSSResultArray, PropertyValues, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+/**
+ * @element luzmo-table-row-details
+ *
+ * Expanded content for the preceding `luzmo-table-row`. Place it as the row's
+ * next sibling. The table shows it while that row is `expanded`.
+ *
+ * @slot - Details content. A nested `luzmo-table` needs its own accessible name.
+ *
+ * @fires luzmo-table-details-collapsed - The closing animation finished and the details row is hidden.
+ */
+export declare class LuzmoTableRowDetails extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    /**
+     * Whether the details row is shown. Set by the table from the owning row.
+     */
+    open: boolean;
+    private _phase;
+    private readonly reducedMotion;
+    private _closeFallback;
+    disconnectedCallback(): void;
+    protected willUpdate(changes: PropertyValues<this>): void;
+    protected render(): TemplateResult;
+    protected updated(changes: PropertyValues): void;
+    private handleAnimationEnd;
+    private _finishClosing;
+}

package/components/table/table-row.d.ts

@@ -0,0 +1,64 @@
+import { CSSResultArray, PropertyValues, TemplateResult } from 'lit';
+import { LuzmoElement } from '../../utils/base';
+import type { ElementSize } from '../../utils/sized-mixin';
+import './table-disclosure-cell';
+/**
+ * @element luzmo-table-row
+ *
+ * @slot - `luzmo-table-cell` elements of the row.
+ */
+export declare class LuzmoTableRow extends LuzmoElement {
+    static get styles(): CSSResultArray;
+    role: string;
+    /**
+     * Selection value. Defaults to the row's position when empty.
+     */
+    value: string;
+    /**
+     * Whether the row is selected. Mirrored from the table's `selected`.
+     */
+    selected: boolean;
+    /**
+     * Whether the row can be selected. Set by the table while it `selects`.
+     */
+    selectable: boolean;
+    /**
+     * Whether the row's details are shown.
+     */
+    expanded: boolean;
+    /**
+     * Whether the row has a details sibling or data-mode details renderer.
+     */
+    expandable: boolean;
+    /** @internal */
+    selectsSingle: boolean;
+    /** @internal */
+    emphasized: boolean;
+    /**
+     * Whether the table renders a selection column. Rows that cannot be
+     * selected keep the column's space so cells stay aligned.
+     * @internal
+     */
+    selectionColumn: boolean;
+    /**
+     * Whether the table renders a disclosure column. Rows that cannot expand
+     * keep the column's space so cells stay aligned.
+     * @internal
+     */
+    expansionColumn: boolean;
+    /**
+     * Spans the row's only cell across every column. Used by information rows.
+     * @internal
+     */
+    spanAll: boolean;
+    /** @internal */
+    checkboxLabel: string;
+    /** @internal */
+    disclosureLabel: string;
+    /** @internal */
+    detailsId: string;
+    /** @internal */
+    checkboxSize: ElementSize;
+    protected render(): TemplateResult;
+    protected updated(changes: PropertyValues<this>): void;
+}

package/components/table/table-styles.d.ts

@@ -0,0 +1,9 @@
+import { CSSResultArray, CSSResultGroup } from 'lit';
+/**
+ * `LuzmoElement` declares no `styles`, so `super.styles` is `undefined` and
+ * cannot be spread directly. Flatten whatever is inherited so the table
+ * elements keep base styles if the base class starts contributing them.
+ *
+ * @internal
+ */
+export declare function tableStyles(inherited: CSSResultGroup | undefined, styles: string): CSSResultArray;