@navette-js/tables 1.0.0-beta.2 → 1.0.0-beta.4

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import type { DataAdapter, ListQuery, Page as RecordPage, SortDirection } from '@navette-js/database';
 import { Attributes, type ColorManager } from '@navette-js/support';
+import { type RelationshipQueryModifier } from './query-builder.ts';
 export * from './query-builder.ts';
 /** Render hook slots of a table. */
 export declare const TablesRenderHook: {
@@ -27,7 +28,6 @@ export declare const TablesRenderHook: {
     readonly TOOLBAR_TOGGLE_COLUMN_TRIGGER_AFTER: "tables::toolbar.toggle-column-trigger.after";
     readonly TOOLBAR_TOGGLE_COLUMN_TRIGGER_BEFORE: "tables::toolbar.toggle-column-trigger.before";
 };
-/** Methods and properties that trigger the table's loading state (`wire:target`). */
 export declare const LOADING_TARGETS = "activeTab,applyTableFilters,gotoPage,nextPage,previousPage,removeTableFilter,removeTableFilters,reorderTable,resetTableColumnSearch,resetTableFiltersForm,resetTableSearch,setPage,sortTable,tableColumnSearches,tableFilters,tableGrouping,tableRecordsPerPage,tableSearch,tableSort,toggleTableReordering";
 type StateResolver<R> = (ctx: {
     record: R;
@@ -63,6 +63,20 @@ export declare abstract class Column<R = any> {
     isSortInverted(): boolean;
     /** Link on the cell; takes precedence over the row action. */
     url(resolver: (record: R) => string | null): this;
+    protected _cellAction: string | {
+        getName(): string;
+    } | null;
+    /**
+     * Clicking the cell runs an action on its record: the name of a record action of the table, or an `Action` (checked and
+     * authorized like record actions when it is mounted). A column `url()` takes precedence; the action takes precedence over the row's link and action.
+     */
+    action(action: string | {
+        getName(): string;
+    } | null): this;
+    getAction(): {
+        getName(): string;
+    } | null;
+    getActionName(): string | null;
     getUrl(record: R): string | null;
     /** `isGlobal: false` excludes the column from the global search; `isIndividual` adds a search field for this column. */
     getSearchColumn(): string;
@@ -76,10 +90,42 @@ export declare abstract class Column<R = any> {
         isToggledHiddenByDefault?: boolean;
     }): this;
     alignment(alignment: 'start' | 'center' | 'end' | null): this;
+    protected _visibleFrom: string | null;
+    protected _hiddenFrom: string | null;
+    protected _columnWidth: string | null;
+    protected _grow: boolean | null;
+    protected _wrapHeader: boolean;
+    /** Shows the column only from this screen size up (`sm`, `md`, `lg`, `xl`, `2xl`). */
+    visibleFrom(breakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | null): this;
+    /** Hides the column from this screen size up. */
+    hiddenFrom(breakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | null): this;
+    /** Classes hiding the header and cells on some screen sizes. */
+    getResponsiveClasses(): string[];
+    /** Width of the column, as a CSS length (`200px`, `20%`...). */
+    width(width: string | number | null): this;
+    getWidth(): string | null;
+    /** The column takes the remaining width of the table (when it has no `width()`). */
+    grow(condition?: boolean): this;
+    /** In a table, columns do not grow unless told to; in a layout (split), they do. */
+    canGrow(defaultValue?: boolean): boolean;
+    /** Lets a long label wrap in the header. */
+    wrapHeader(condition?: boolean): this;
+    canHeaderWrap(): boolean;
     alignEnd(): this;
     alignLeft(): this;
     alignCenter(): this;
     getStateUsing(resolver: StateResolver<R>): this;
+    /** Fixed state, or a function of the record (alias of `getStateUsing()` for a value). */
+    state(state: unknown | ((record: R) => unknown)): this;
+    protected _default: unknown;
+    /** Value used when the state is empty. */
+    default(value: unknown): this;
+    protected _hidden: boolean | (() => boolean);
+    protected _visible: boolean | (() => boolean);
+    /** Removes the column from the table (header, cells, search, sort and column manager). */
+    hidden(condition?: boolean | (() => boolean)): this;
+    visible(condition?: boolean | (() => boolean)): this;
+    isHidden(): boolean;
     getLabel(): string;
     isSortable(): boolean;
     isGloballySearchable(): boolean;
@@ -94,53 +140,136 @@ export declare abstract class Column<R = any> {
     isClickDisabled(): boolean;
     abstract toHtml(record: R, recordKey?: string | number): Promise<string>;
 }
+/** Value of an option that may depend on the record and the state item. */
+type PerItem<R, T> = T | ((record: R, state: unknown) => T);
+/** Date in a PHP-style format (`M j, Y`, `d/m/Y H:i`…), in UTC or in the given IANA time zone. Database values without a zone are read as UTC. */
+export declare function formatDate(value: unknown, format: string, timeZone?: string | null): string;
 export declare class TextColumn<R = any> extends Column<R> {
     private _weight;
     private _copyable;
+    private _copyableState;
+    private _copyMessage;
+    private _copyMessageDuration;
     private _money;
     private _placeholder;
     private _badge;
     private _color;
     private _icon;
+    private _iconColor;
+    private _iconPosition;
     private _format;
     private _date;
+    private _timeZone;
+    private _since;
     private _numeric;
+    private _decimals;
     private _summarizers;
     private _limit;
+    private _words;
+    private _prefix;
+    private _suffix;
     private _tooltip;
+    private _size;
+    private _fontFamily;
+    private _wrap;
+    private _lineClamp;
+    private _inline;
+    private _descriptionAbove;
+    private _descriptionBelow;
+    private _listWithLineBreaks;
+    private _bulleted;
+    private _listLimit;
+    private _expandableLimitedList;
+    private _separator;
     static make<R = any>(name: string): TextColumn<R>;
     /** Displays the value in a badge. */
     badge(condition?: boolean): this;
-    color(color: string | ((record: R) => string)): this;
-    icon(resolver: (record: R) => string | null): this;
+    /** Text color (or badge color): a color name, or a function of the record and the state item. */
+    color(color: PerItem<R, string | null>): this;
+    /** Icon next to the text: a name, or a function of the record and the state item returning a name or `null`. */
+    icon(icon: PerItem<R, string | null> | null): this;
+    iconColor(color: PerItem<R, string | null>): this;
+    iconPosition(position: 'before' | 'after'): this;
     /** Text displayed instead of the raw value (e.g. an enum label). */
     formatStateUsing(formatter: (ctx: {
         state: unknown;
         record: R;
     }) => string): this;
-    /** Short date, e.g. "Nov 9, 2026". */
-    date(condition?: boolean): this;
-    private _dateTime;
-    /** Date and time, e.g. "Nov 9, 2026 14:30:00". */
-    dateTime(condition?: boolean): this;
-    /** Number formatted with thousands separators. */
-    private _decimals;
-    /** `numeric(1)`: fixed number of decimals. */
+    /** Date in a PHP-style format, `M j, Y` by default ("Nov 9, 2026"). `timeZone`: IANA zone to display the date in. */
+    date(format?: string | boolean, timeZone?: string | null): this;
+    /** Date and time, `M j, Y H:i:s` by default. */
+    dateTime(format?: string | boolean, timeZone?: string | null): this;
+    /** Time only, `H:i:s` by default. */
+    time(format?: string, timeZone?: string | null): this;
+    /** Relative date, e.g. "2 days ago". */
+    since(condition?: boolean): this;
+    /** Time zone used by `date()`, `dateTime()` and `time()`. */
+    timezone(timeZone: string | null): this;
+    /** Number formatted with thousands separators; `numeric(1)`: fixed number of decimals. */
     numeric(condition?: boolean | number): this;
     /** Summary row below the table. */
     summarize(summarizer: Summarizer | Summarizer[]): this;
     getSummarizers(): Summarizer[];
-    weight(weight: string): this;
+    /** Font weight: `thin`, `light`, `medium`, `semibold`, `bold`… */
+    weight(weight: PerItem<R, string | null>): this;
+    /** Text size: `xs`, `sm` (default), `md` or `lg`. */
+    size(size: PerItem<R, string | null>): this;
+    /** Font family: `sans`, `serif` or `mono`. */
+    fontFamily(family: PerItem<R, string | null>): this;
+    /** Lets long text wrap onto several lines instead of overflowing. */
+    wrap(condition?: boolean): this;
+    /** Clamps the text to this number of lines. */
+    lineClamp(lines: number | null): this;
+    /** Renders inline (without a block layout), e.g. inside a stacked layout. */
+    inline(condition?: boolean): this;
     /** Truncates the displayed text to `length` characters, followed by "...". */
     limit(length: number | null): this;
+    /** Truncates the displayed text to this number of words, followed by "...". */
+    words(count: number | null): this;
+    prefix(prefix: string | null): this;
+    suffix(suffix: string | null): this;
     /** Tooltip on hover; `null` for none. */
-    tooltip(tooltip: ((record: R) => string | null) | string | null): this;
-    copyable(condition?: boolean): this;
+    tooltip(tooltip: PerItem<R, string | null>): this;
+    copyable(condition?: PerItem<R, boolean>): this;
+    /** Value copied to the clipboard, when it differs from the displayed text. */
+    copyableState(state: PerItem<R, string | null>): this;
+    copyMessage(message: string | null): this;
+    copyMessageDuration(milliseconds: number): this;
     /** Amount formatted in the given currency, e.g. `money('usd')`. */
     money(currency?: string | ((record: R) => string)): this;
     /** Text displayed when the value is empty. */
     placeholder(text: string | null): this;
-    /** Cell content: a short markup for plain text, a full markup as soon as an option (badge, icon, color…) is set. */
+    /** Secondary text below the value (`'below'`, the default) or above it. */
+    description(text: ((record: R) => string | null) | string | null, position?: 'above' | 'below'): this;
+    /** One value per line, for a state that is a list (or a string split by `separator()`). */
+    listWithLineBreaks(condition?: boolean): this;
+    /** Bulleted list. */
+    bulleted(condition?: boolean): this;
+    /** Shows only the first values of a list; `expandable`: a link reveals the others. */
+    limitList(count: number | null, expandable?: boolean): this;
+    expandableLimitedList(condition?: boolean): this;
+    /** Splits a string state into a list on this separator. */
+    separator(separator?: string | null): this;
+    private _html;
+    private _markdown;
+    /**
+     * Renders the state as HTML. It is sanitized first: only formatting elements (paragraphs, emphasis, lists, links with safe
+     * URLs...) are kept, without any attribute that could run scripts or change the page's styles.
+     */
+    html(condition?: PerItem<R, boolean>): this;
+    /** Renders the state as Markdown. Raw HTML in it is shown as text, and links only keep safe URLs. */
+    markdown(condition?: PerItem<R, boolean>): this;
+    /** Item text as HTML: Markdown, sanitized HTML, or escaped text. */
+    private renderItemText;
+    /** Displayed text of one state item, escaped by the caller. */
+    private formatItem;
+    private stateItems;
+    private hasDescriptions;
+    /** Plain value without per-item options: Filament's short markup. */
+    private canRenderOptimized;
+    private alignClass;
+    private containerClasses;
+    /** Cell content, as Filament renders it: a short markup for a plain value, the full markup as soon as an item option is set. */
     toHtml(record: R): Promise<string>;
 }
 /** Values a summarizer works from: aggregates over the query (all records) or over the displayed page. */
@@ -152,41 +281,94 @@ export type SummaryValues = {
     max: Record<string, unknown>;
 };
 export type SummaryItem = {
-    type: 'text' | 'range';
+    type: 'text' | 'range' | 'values';
     label: string | null;
     value: string;
+    labelHidden?: boolean;
+    values?: string[];
+    bulleted?: boolean;
+};
+/** Records a custom summarizer works on: all records, the displayed page, or a group. */
+export type SummaryDataset = {
+    column: string;
+    records: () => Promise<any[]>;
 };
-/** Column summary below the table: sum, average, count or range. */
-export declare abstract class Summarizer {
-    abstract readonly kind: 'sum' | 'avg' | 'count' | 'range';
+/**
+ * Column summary below the table: sum, average, count, range, distinct values, or your own with `Summarizer.make().using()`.
+ */
+export declare class Summarizer {
+    readonly kind: 'sum' | 'avg' | 'count' | 'range' | 'values' | 'custom';
     protected _label: string | null;
     protected _money: string | null;
+    protected _decimals: number | null;
+    protected _prefix: string | null;
+    protected _suffix: string | null;
+    protected _formatStateUsing: ((state: unknown) => string | null) | null;
+    protected _labelHidden: boolean;
+    protected _hidden: boolean | (() => boolean);
+    protected _using: ((dataset: SummaryDataset) => unknown) | null;
+    protected _scope: ((query: any) => void) | null;
+    /**
+     * Restricts the records summarized by this summarizer (all records, the page, or a group), e.g.
+     * `Count.make().query((query) => query.where('is_published', 1))`. The function receives the data adapter's query builder.
+     */
+    query(scope: ((query: any) => void) | null): this;
+    getQueryScope(): ((query: any) => void) | null;
+    static make(): Summarizer;
     label(label: string | null): this;
     money(currency?: string): this;
+    /** Number formatting, with a fixed number of decimals. */
+    numeric(decimals?: number | null): this;
+    prefix(prefix: string | null): this;
+    suffix(suffix: string | null): this;
+    /** Formats the value yourself (the result is escaped). */
+    formatStateUsing(callback: ((state: unknown) => string | null) | null): this;
+    /** Keeps the label for screen readers only. */
+    hiddenLabel(condition?: boolean): this;
+    isLabelHidden(): boolean;
+    hidden(condition?: boolean | (() => boolean)): this;
+    visible(condition?: boolean | (() => boolean)): this;
+    isHidden(): boolean;
+    /** Computes the value from the summarized records (`records()` loads them: keep the dataset small). */
+    using(callback: ((dataset: SummaryDataset) => unknown) | null): this;
+    hasCustomCalculation(): boolean;
+    compute(dataset: SummaryDataset): Promise<unknown>;
     getLabel(): string | null;
-    format(value: number): string;
-    abstract summarize(column: string, values: SummaryValues): SummaryItem | null;
+    /** Formatted value: `formatStateUsing()`, money or number, then the prefix and suffix. */
+    format(value: unknown): string;
+    protected item(value: unknown, type?: SummaryItem['type']): SummaryItem;
+    /** Summary item from the aggregates (or from `customValue`, computed by `using()`). */
+    summarize(_column: string, _values: SummaryValues, customValue?: unknown): SummaryItem | null;
 }
 /** Column total. */
 export declare class Sum extends Summarizer {
     readonly kind = "sum";
     static make(): Sum;
     getLabel(): string;
-    summarize(column: string, values: SummaryValues): SummaryItem;
+    summarize(column: string, values: SummaryValues, customValue?: unknown): SummaryItem;
 }
 /** Column average. */
 export declare class Average extends Summarizer {
     readonly kind = "avg";
     static make(): Average;
     getLabel(): string;
-    summarize(column: string, values: SummaryValues): SummaryItem;
+    summarize(column: string, values: SummaryValues, customValue?: unknown): SummaryItem;
 }
 /** Record count. */
 export declare class Count extends Summarizer {
     readonly kind = "count";
     static make(): Count;
     getLabel(): string;
-    summarize(_column: string, values: SummaryValues): SummaryItem;
+    summarize(_column: string, values: SummaryValues, customValue?: unknown): SummaryItem;
+}
+/** Distinct values of the column, as a (bulleted) list. */
+export declare class Values extends Summarizer {
+    readonly kind = "values";
+    private _bulleted;
+    static make(): Values;
+    bulleted(condition?: boolean): this;
+    constructor();
+    summarize(_column: string, _values: SummaryValues, customValue?: unknown): SummaryItem;
 }
 /** Smallest and largest value of a column. */
 export declare class Range extends Summarizer {
@@ -195,7 +377,7 @@ export declare class Range extends Summarizer {
     static make(): Range;
     /** Dates: day only when the bounds fall on different days, day and time otherwise; a single value when both are equal. */
     minimalDateTimeDifference(condition?: boolean): this;
-    summarize(column: string, values: SummaryValues): SummaryItem | null;
+    summarize(column: string, values: SummaryValues, _customValue?: unknown): SummaryItem | null;
 }
 /** Row grouping: rows are sorted by the column and each group gets a header row. */
 export declare class Group<R = any> {
@@ -207,7 +389,17 @@ export declare class Group<R = any> {
     private _collapsible;
     private _date;
     private _titlePrefixedWithLabel;
+    private _keyUsing;
+    private _scopeUsing;
+    private _orderUsing;
     constructor(id: string);
+    /** Group key of a record, when it is not the column value (records with the same key form a group). Use with `scopeQueryByKeyUsing()`. */
+    getKeyFromRecordUsing(resolver: ((record: R) => string | null) | null): this;
+    /** Restricts the query to one group (summaries, "select the group"): needed when `getKeyFromRecordUsing()` is not the column value. */
+    scopeQueryByKeyUsing(scope: ((query: any, key: string | null) => void) | null): this;
+    /** Orders the query by group, when ordering by the column is not right (e.g. a status with a custom order). */
+    orderQueryUsing(order: ((query: any, direction: SortDirection) => void) | null): this;
+    getOrderQueryUsing(): ((query: any, direction: SortDirection) => void) | null;
     static make<R = any>(id: string): Group<R>;
     label(label: string | null): this;
     /** Query column holding the group value, when it differs from the id (relationship). */
@@ -242,11 +434,41 @@ export declare class Group<R = any> {
  */
 export declare abstract class ColumnLayout<R = any> {
     protected _children: (Column<R> | ColumnLayout<R>)[];
+    protected _grow: boolean | null;
+    protected _visibleFrom: string | null;
+    protected _hiddenFrom: string | null;
+    protected _columnSpan: Record<string, number | string>;
+    protected _collapsible: boolean;
+    protected _collapsed: boolean;
+    protected _hidden: boolean | (() => boolean);
     constructor(children: (Column<R> | ColumnLayout<R>)[]);
     getChildren(): (Column<R> | ColumnLayout<R>)[];
     /** Leaf columns, in order: the ones the table sorts, searches and toggles. */
     getColumns(): Column<R>[];
     abstract getClasses(): string[];
+    /** `false`: the component takes only the width it needs in a split, instead of sharing the remaining space. */
+    grow(condition?: boolean): this;
+    canGrow(): boolean;
+    visibleFrom(breakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | null): this;
+    hiddenFrom(breakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | null): this;
+    getResponsiveClasses(): string[];
+    /** Columns of a parent `Grid` taken by the component: a number, `'full'`, or one per breakpoint. */
+    columnSpan(span: number | string | Record<string, number | string>): this;
+    columnSpanFull(): this;
+    getColumnSpan(): Record<string, number | string>;
+    /**
+     * Content hidden behind a toggle button at the bottom of the record. Only one top-level component of the layout can
+     * be collapsible. It starts collapsed; `collapsed(false)` shows it open.
+     */
+    collapsible(condition?: boolean): this;
+    collapsed(condition?: boolean): this;
+    isCollapsible(): boolean;
+    isCollapsed(): boolean;
+    hidden(condition?: boolean | (() => boolean)): this;
+    visible(condition?: boolean | (() => boolean)): this;
+    isHidden(): boolean;
+    /** Inner markup of the component, around the already rendered children. */
+    renderContent(children: string[], _record: R, _key: string): Promise<string>;
 }
 /** Columns side by side, from a given breakpoint. */
 export declare class Split<R = any> extends ColumnLayout<R> {
@@ -265,6 +487,46 @@ export declare class Stack<R = any> extends ColumnLayout<R> {
     alignment(alignment: 'start' | 'center' | 'end'): this;
     getClasses(): string[];
 }
+/** Responsive grid of columns: `Grid.make(2)` (2 columns from `lg`) or `Grid.make({ default: 1, md: 2, xl: 3 })`. */
+export declare class Grid<R = any> extends ColumnLayout<R> {
+    private _gridColumns;
+    constructor(columns?: number | Record<string, number> | null);
+    static make<R = any>(columns?: number | Record<string, number> | null): Grid<R>;
+    /** Number of columns, or one per breakpoint (\`default\`, \`sm\`, \`md\`, \`lg\`, \`xl\`, \`2xl\`). */
+    columns(columns?: number | Record<string, number> | null): this;
+    /** Components of the grid. */
+    schema(children: (Column<R> | ColumnLayout<R>)[]): this;
+    getGridColumns(): Record<string, number>;
+    getClasses(): string[];
+    renderContent(children: string[]): Promise<string>;
+}
+/** Plain container, styled as a panel: often made collapsible. */
+export declare class Panel<R = any> extends ColumnLayout<R> {
+    static make<R = any>(children: (Column<R> | ColumnLayout<R>)[]): Panel<R>;
+    getClasses(): string[];
+}
+/**
+ * Your own markup inside the record: a function returning HTML, or the name of an EJS view rendered with `record` and
+ * `recordKey`. The HTML is inserted as it is: escape record data with `e()` (EJS's `<%= %>` does it).
+ */
+export declare class View<R = any> extends ColumnLayout<R> {
+    private _view;
+    private _viewData;
+    constructor(view: string | ((ctx: {
+        record: R;
+        recordKey: string;
+    }) => string | Promise<string>));
+    static make<R = any>(view: string | ((ctx: {
+        record: R;
+        recordKey: string;
+    }) => string | Promise<string>)): View<R>;
+    /** Extra data passed to the EJS view. */
+    viewData(data: Record<string, unknown>): this;
+    /** Columns rendered inside the view are not part of the table: the view has no children. */
+    components(children: (Column<R> | ColumnLayout<R>)[]): this;
+    getClasses(): string[];
+    renderContent(children: string[], record: R, key: string): Promise<string>;
+}
 /** Column group: a shared label above the column headers. */
 export declare class ColumnGroup<R = any> {
     private label;
@@ -274,28 +536,108 @@ export declare class ColumnGroup<R = any> {
     columns(columns: Column<R>[]): this;
     getColumns(): Column<R>[];
 }
-/** Color swatch column. */
+/** Color swatch per state (a color, or a list of colors). */
 export declare class ColorColumn<R = any> extends Column<R> {
+    private _copyable;
+    private _copyMessage;
+    private _copyMessageDuration;
+    private _tooltip;
+    private _placeholder;
+    private _wrap;
+    private _inline;
     static make<R = any>(name: string): ColorColumn<R>;
+    /** Clicking the swatch copies the color. Browsers only expose the clipboard on HTTPS or `localhost`. */
+    copyable(condition?: PerItem<R, boolean>): this;
+    copyMessage(message: string | null): this;
+    copyMessageDuration(milliseconds: number): this;
+    tooltip(tooltip: PerItem<R, string | null>): this;
+    placeholder(text: string | null): this;
+    /** Lets several swatches wrap onto more lines. */
+    wrap(condition?: boolean): this;
+    inline(condition?: boolean): this;
     toHtml(record: R): Promise<string>;
 }
-/** Image column: the state is the image URL. Only local or http(s) URLs are rendered. */
+/** Image per state (an image URL, or a list of URLs). Only local or http(s) URLs are rendered. */
 export declare class ImageColumn<R = any> extends Column<R> {
     private _alt;
     private _height;
+    private _width;
     private _circular;
+    private _square;
+    private _stacked;
+    private _ring;
+    private _overlap;
+    private _limit;
+    private _limitedRemainingText;
+    private _limitedRemainingTextSize;
+    private _defaultImageUrl;
+    private _tooltip;
+    private _placeholder;
+    private _wrap;
+    private _inline;
     static make<R = any>(name: string): ImageColumn<R>;
-    alt(resolver: (record: R) => string | null): this;
-    /** CSS height of the image (`2.5rem` by default). */
-    imageHeight(height: string): this;
+    alt(alt: PerItem<R, string | null>): this;
+    /** CSS height of the images (`2.5rem` by default, `2rem` when stacked). */
+    imageHeight(height: string | number | null): this;
+    imageWidth(width: string | number | null): this;
+    /** Same width and height. */
+    imageSize(size: string | number | null): this;
     circular(condition?: boolean): this;
+    square(condition?: boolean): this;
+    /** Overlapping images, with a `ring` (border width, 0 to 8) and an `overlap` (0 to 8). */
+    stacked(condition?: boolean): this;
+    ring(width: number | null): this;
+    overlap(overlap: number | null): this;
+    /** Shows only the first images; `limitedRemainingText()` adds "+3" for the others. */
+    limit(count: number | null): this;
+    limitedRemainingText(condition?: boolean, size?: string | null): this;
+    /** Image shown when the state is empty. */
+    defaultImageUrl(url: string | ((record: R) => string | null) | null): this;
+    tooltip(tooltip: PerItem<R, string | null>): this;
+    placeholder(text: string | null): this;
+    wrap(condition?: boolean): this;
+    inline(condition?: boolean): this;
     toHtml(record: R): Promise<string>;
 }
 /** Icon depending on the value; `boolean()` shows a green check or a red cross. */
+/**
+ * Icon per state. `boolean()` shows a green check or a red cross; `icon()` and `color()` choose the icon and color from the
+ * record and the state, e.g. `IconColumn.make('status').icon((record) => STATUSES[record.status].icon)`.
+ */
 export declare class IconColumn<R = any> extends Column<R> {
     private _boolean;
+    private _icon;
+    private _color;
+    private _size;
+    private _trueIcon;
+    private _falseIcon;
+    private _trueColor;
+    private _falseColor;
+    private _tooltip;
+    private _placeholder;
+    private _listWithLineBreaks;
+    private _wrap;
+    private _inline;
     static make<R = any>(name: string): IconColumn<R>;
     boolean(condition?: boolean): this;
+    icon(icon: PerItem<R, string | null> | null): this;
+    color(color: PerItem<R, string | null> | null): this;
+    /** Icon size: `xs`, `sm`, `md`, `lg` (default), `xl` or `2xl`. */
+    size(size: PerItem<R, string | null>): this;
+    /** Icons and colors of a boolean column; `false` shows no icon for that value. */
+    trueIcon(icon: string | false | null): this;
+    falseIcon(icon: string | false | null): this;
+    trueColor(color: string | null): this;
+    falseColor(color: string | null): this;
+    tooltip(tooltip: PerItem<R, string | null>): this;
+    placeholder(text: string | null): this;
+    /** One icon per line, for a state that is a list. */
+    listWithLineBreaks(condition?: boolean): this;
+    wrap(condition?: boolean): this;
+    inline(condition?: boolean): this;
+    private isBooleanItem;
+    private iconOf;
+    private colorOf;
     toHtml(record: R): Promise<string>;
 }
 /** Application-defined validation rule of an editable column: synchronous check and message (`:attribute` already replaced). */
@@ -345,6 +687,8 @@ export declare abstract class EditableColumn<R = any> extends Column<R> {
      * Error message, or `null` if the value is valid. An empty value is only checked by `required`, and several errors
      * produce the first message followed by "(and N more errors)".
      */
+    /** Validation of a value for a given record (column types whose rules depend on the record override it). */
+    validateFor(_record: R, input: unknown): Promise<string | null>;
     validate(input: unknown): string | null;
     /** Custom write, replacing the update of the record's column. Its return value is sent back to the browser. */
     updateStateUsing(callback: StateHook<R> | null): this;
@@ -361,7 +705,7 @@ export declare abstract class EditableColumn<R = any> extends Column<R> {
      */
     updateState(record: R, input: unknown, adapter: Pick<DataAdapter<R>, 'getKey' | 'update'>): Promise<unknown>;
     /** `x-tooltip` expression of editable controls: the column tooltip, replaced by the validation error when there is one. */
-    protected tooltipExpression(record: R): string;
+    protected tooltipExpression(record: R, extra?: string | null): string;
     /** Shared opening markup of editable cells: lazily loaded Alpine component, server state and record key. */
     protected editableAttributes(component: string, asset: string, recordKey: string | number, state: unknown): Attributes;
     protected static readonly STATUS_HTML = "<p x-cloak x-show=\"error\" x-bind:id=\"$id('table-column-error')\" x-ref=\"error\" x-text=\"error\" class=\"fi-sr-only\"></p><p role=\"status\" aria-live=\"polite\" aria-atomic=\"true\" x-text=\"status\" class=\"fi-sr-only\"></p>";
@@ -369,14 +713,56 @@ export declare abstract class EditableColumn<R = any> extends Column<R> {
 /**
  * In-cell editable select (native select only). The received value must be one of the declared options.
  */
+export type SelectColumnOptions = [string, string][] | Record<string, string>;
 export declare class SelectColumn<R = any> extends EditableColumn<R> {
     private _options;
     private _selectablePlaceholder;
+    private _native;
+    private _searchable;
+    private _disabledOptions;
+    private _placeholder;
+    private _optionsLimit;
+    private _canOptionLabelsWrap;
+    private _position;
+    private _inline;
     static make<R = any>(name: string): SelectColumn<R>;
-    options(options: [string, string][] | Record<string, string>): this;
+    /** `{ value: label }` pairs, `[value, label]` pairs, or a function of the record returning either. */
+    options(options: SelectColumnOptions | ((record: R) => SelectColumnOptions | Promise<SelectColumnOptions>)): this;
+    /** Static options (empty when they depend on the record: use `getOptionsFor()`). */
     getOptions(): [string, string][];
+    getOptionsFor(record: R): Promise<[string, string][]>;
+    private _optionsRelationship;
+    private _relationshipOptions;
+    /**
+     * Options from the records of a relationship of the record's model (an Objection model with `relationMappings`): the
+     * column stores the picked record's key, e.g. `SelectColumn.make('author_id').optionsRelationship('author', 'name')`.
+     * Up to 1,000 options are listed; any related record's key is accepted when saving.
+     */
+    optionsRelationship(name: string, titleAttribute?: string | null, modifyQueryUsing?: RelationshipQueryModifier | null): this;
     selectablePlaceholder(condition?: boolean): this;
+    /** `false`: a JavaScript select instead of the browser's native one. */
+    native(condition?: boolean): this;
+    private _allowHtml;
+    /** Option labels are HTML, sanitized on the server (JavaScript select only; the native select shows their text). */
+    allowHtml(condition?: boolean): this;
+    private labelForDisplay;
+    /** A search field in the select (implies a JavaScript select). */
+    searchableOptions(condition?: boolean): this;
+    isNative(): boolean;
+    /** Options that cannot be chosen. A disabled option is also refused on the server. */
+    disableOptionWhen(callback: (value: string, label: string, record: R) => boolean): this;
+    isOptionDisabled(value: string, label: string, record: R): boolean;
+    placeholder(text: string | null): this;
+    /** Maximum number of options listed by the JavaScript select (50 by default). */
+    optionsLimit(limit: number): this;
+    /** `false`: long option labels are truncated in the JavaScript select instead of wrapping. */
+    allowOptionsLabelsWrap(condition?: boolean): this;
+    /** Side where the JavaScript select's dropdown opens (automatic by default). */
+    position(position: 'top' | 'bottom' | null): this;
+    inline(condition?: boolean): this;
     protected getImplicitRules(): ColumnValidationRule[];
+    /** The value must be one of the record's options, and not a disabled one. */
+    validateFor(record: R, input: unknown): Promise<string | null>;
     toHtml(record: R, recordKey?: string | number): Promise<string>;
 }
 /** In-cell editable toggle. The received value must be a boolean (`boolean` rule by default). */
@@ -473,17 +859,22 @@ export declare function updateTableColumnState<R>(table: Table<R>, host: TableHo
 /** Filter state: the values of its form. */
 export type FilterState = Record<string, unknown>;
 /** Active filter indicator: its label, and the filter field cleared when it is removed. */
+/** Active filter indicator: its label, the filter field cleared when it is removed (`''`: the whole filter), whether it can be removed, and its badge color. */
 export type FilterIndicator = {
     label: string;
     field: string;
+    removable?: boolean;
+    color?: string | null;
 };
-/** Filters layout: toolbar dropdown (default), or collapsible panel above the content. */
-export type FiltersLayout = 'dropdown' | 'above-content-collapsible';
+/** Where the filters form is shown: in a toolbar dropdown (default) or modal, or in a panel around the table content. */
+export type FiltersLayout = 'dropdown' | 'modal' | 'above-content' | 'above-content-collapsible' | 'below-content' | 'before-content' | 'before-content-collapsible' | 'after-content' | 'after-content-collapsible';
 export interface TableFilter {
     readonly name: string;
     getLabel(): string;
     /** Initial state (empty form). */
     getDefaultState(): FilterState;
+    /** State after the filter is removed (its indicator or "remove all"); `getDefaultState()` when absent. */
+    getResetState?(): FilterState;
     /** Options of the `value` field as [value, label] pairs, and the empty option's label. */
     getFormDefinition(): {
         placeholder: string;
@@ -504,88 +895,204 @@ export interface TableFilter {
     /** Data loaded from the database before indicators are computed (e.g. related record labels). */
     loadIndicatorData?(state: FilterState, host: TableHost): Promise<void>;
 }
-/** "Trashed" filter for soft-deletable models. */
-export declare class TrashedFilter implements TableFilter {
-    readonly name = "trashed";
-    static make(): TrashedFilter;
+/** Badge shown above the table for an applied filter. */
+export declare class Indicator {
+    private _label;
+    private _removeField;
+    private _removable;
+    private _color;
+    constructor(label: string);
+    static make(label: string): Indicator;
+    label(label: string): this;
     getLabel(): string;
-    getDefaultState(): FilterState;
+    /** Field of the filter form cleared when the indicator is removed (by default, the whole filter is reset). */
+    removeField(field: string | null): this;
+    getRemoveField(): string | null;
+    /** `false`: no remove button. A forged removal is refused on the server too. */
+    removable(condition?: boolean): this;
+    isRemovable(): boolean;
+    color(color: string | null): this;
+    getColor(): string | null;
+}
+/** What `indicateUsing()` may return: a label, an `Indicator`, a list of them, or `{ field: label }` pairs. */
+export type IndicatorResult = string | Indicator | null | undefined | (string | Indicator)[] | Record<string, string | Indicator>;
+/** Shared options of the built-in filters: label, default state, indicators and custom query. */
+declare abstract class BaseFilter implements TableFilter {
+    readonly name: string;
+    protected _label: string | null;
+    protected _default: unknown;
+    protected _indicator: string | Indicator | null;
+    protected _indicateUsing: ((data: FilterState) => IndicatorResult) | null;
+    protected _query: ((query: any, data: FilterState) => void) | null;
+    protected _columnSpan: Record<string, number | string>;
+    constructor(name: string);
+    label(label: string): this;
+    getLabel(): string;
+    /** State applied when the table opens and when the user clicks "Reset". */
+    default(value?: unknown): this;
+    /** Label of the indicator (the filter label by default). */
+    indicator(indicator: string | Indicator | null): this;
+    getIndicator(): string | Indicator;
+    /** Indicators of the applied state, replacing the default one. */
+    indicateUsing(callback: ((data: FilterState) => IndicatorResult) | null): this;
+    /** Query condition built from the sanitized state, replacing the default one. */
+    query(modifier: (query: any, data: FilterState) => void): this;
+    /** Width of the filter in the filters form grid. */
+    columnSpan(span: number | string | Record<string, number | string>): this;
+    columnSpanFull(): this;
+    getColumnSpan(): Record<string, number | string>;
+    /** State after removing the filter: blank, whatever the default. */
+    abstract getResetState(): FilterState;
+    abstract getDefaultState(): FilterState;
+    abstract sanitizeState(state: unknown): FilterState;
+    abstract isActive(state: FilterState): boolean;
+    abstract apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
     getFormDefinition(): {
         placeholder: string;
         options: [string, string][];
     };
-    isActive(state: FilterState): boolean;
-    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+    protected defaultIndicators(_data: FilterState): IndicatorResult;
+    getIndicators(state: FilterState): FilterIndicator[];
+    /** Prefixes a value label with the indicator, unless the indicator is a ready-made `Indicator`. */
+    protected labelled(valueLabel: string): string | Indicator;
 }
-/** Filters on a column value picked from a list (single select). */
-export declare class SelectFilter implements TableFilter {
-    readonly name: string;
-    private _label;
+/** Filters on a column value picked from a list. */
+export declare class SelectFilter extends BaseFilter {
     private _column;
     private _options;
-    constructor(name: string);
+    private _multiple;
+    private _searchable;
+    private _selectablePlaceholder;
+    private _placeholder;
+    private _optionLabels;
     static make(name: string): SelectFilter;
-    label(label: string): this;
     /** Filtered column when it differs from the filter name (e.g. a relationship's foreign key). */
     column(column: string): this;
+    attribute(column: string): this;
+    getColumn(): string;
     /** Fixed options, or an async function (e.g. records of a relationship). */
     options(options: [string, string][] | Record<string, string> | (() => Promise<[string, string][]>)): this;
-    getLabel(): string;
-    getDefaultState(): FilterState;
+    /** Several values can be picked: records matching any of them are shown. */
+    multiple(condition?: boolean): this;
+    isMultiple(): boolean;
+    searchable(condition?: boolean): this;
+    /** `false`: the empty option cannot be picked again once a value is chosen. */
+    selectablePlaceholder(condition?: boolean): this;
+    placeholder(placeholder: string | null): this;
+    /** No-op: options are always loaded with the form. */
+    preload(): this;
+    private _relationship;
+    private _emptyOptionLabel;
+    private _host;
+    /**
+     * Options from the records of a relationship of the table's model (an Objection model with `relationMappings`); records
+     * related to the picked ones are shown. `hasEmptyOption` adds a "None" option for records without related records.
+     */
+    relationship(name: string, titleAttribute?: string | null, modifyQueryUsing?: RelationshipQueryModifier | null, hasEmptyOption?: boolean): this;
+    hasRelationship(): boolean;
+    /** Label of the "None" option of `relationship(..., hasEmptyOption: true)`. */
+    emptyRelationshipOptionLabel(label: string | null): this;
+    getEmptyRelationshipOptionLabel(): string;
     getFormDefinition(): {
         placeholder: string;
         options: [string, string][];
     };
-    getFormOptions(): Promise<[string, string][]>;
+    getFormOptions(host?: unknown): Promise<[string, string][]>;
+    private loadRelationshipOptions;
     /** Options are evaluated on every render, so the select gets a key derived from them (forces a re-render when they change). */
     readonly hasDynamicOptions = true;
+    getFormComponents(): unknown[];
+    private defaultValues;
+    getResetState(): FilterState;
+    getDefaultState(): FilterState;
+    sanitizeState(state: unknown): FilterState;
+    /** Values that can filter: with fixed options, only offered values; loaded options are bound parameters (an unknown value matches nothing). */
+    private values;
     isActive(state: FilterState): boolean;
     apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+    /** Labels of the applied values, loaded before the indicators are computed. */
+    loadIndicatorData(state: FilterState, host?: TableHost): Promise<void>;
+    protected defaultIndicators(data: FilterState): IndicatorResult;
 }
-/** Three-state filter on a boolean column: all, yes, no. */
-export declare class TernaryFilter implements TableFilter {
-    readonly name: string;
-    private _label;
-    constructor(name: string);
+/** Three-state filter: all, yes, no. By default on a boolean column; `nullable()` checks whether the column is filled. */
+export declare class TernaryFilter extends BaseFilter {
+    private _column;
+    protected _trueLabel: string | null;
+    protected _falseLabel: string | null;
+    protected _placeholder: string | null;
+    protected _nullable: boolean;
+    protected _queries: {
+        true: (query: any) => void;
+        false: (query: any) => void;
+        blank?: (query: any) => void;
+    } | null;
     static make(name: string): TernaryFilter;
-    label(label: string): this;
-    getLabel(): string;
-    getDefaultState(): FilterState;
+    attribute(column: string): this;
+    column(column: string): this;
+    getColumn(): string;
+    trueLabel(label: string | null): this;
+    falseLabel(label: string | null): this;
+    placeholder(label: string | null): this;
+    getTrueLabel(): string;
+    getFalseLabel(): string;
+    /** "Yes" shows records where the column is filled, "No" those where it is empty. */
+    nullable(condition?: boolean): this;
+    /** Custom conditions for "yes", "no" and, optionally, the empty choice. */
+    queries(queries: {
+        true: (query: any) => void;
+        false: (query: any) => void;
+        blank?: (query: any) => void;
+    }): this;
     getFormDefinition(): {
         placeholder: string;
         options: [string, string][];
     };
+    getFormComponents(): unknown[];
+    getResetState(): FilterState;
+    getDefaultState(): FilterState;
+    sanitizeState(state: unknown): FilterState;
     isActive(state: FilterState): boolean;
     apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+    protected defaultIndicators(data: FilterState): IndicatorResult;
 }
-/** Custom form filter (`schema()`): the query and indicators are written by the application. */
-export declare class Filter implements TableFilter {
-    readonly name: string;
-    private _label;
-    private _components;
-    private _query;
-    private _indicate;
-    constructor(name: string);
-    static make(name: string): Filter;
-    label(label: string): this;
-    /** Filter fields; their names are the only state keys accepted from the browser. */
-    schema(components: unknown[]): this;
-    /** Query condition built from the sanitized form state. */
-    query(modifier: (query: any, data: FilterState) => void): this;
-    /** Indicators of applied values as `{ field: label }`; removing one clears its field. */
-    indicateUsing(resolver: (data: FilterState) => Record<string, string>): this;
-    private fields;
+/** "Trashed" filter for soft-deletable models: without (default), with, or only deleted records. */
+export declare class TrashedFilter extends TernaryFilter {
+    constructor(name?: string);
+    static make(name?: string): TrashedFilter;
     getLabel(): string;
-    getDefaultState(): FilterState;
+    getTrueLabel(): string;
+    getFalseLabel(): string;
     getFormDefinition(): {
         placeholder: string;
         options: [string, string][];
     };
+    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+    protected defaultIndicators(data: FilterState): IndicatorResult;
+}
+/**
+ * Custom filter. Without `schema()`, it is a checkbox (or a toggle with `toggle()`) and `query()` runs when it is checked.
+ * With `schema()`, the query and indicators are written by the application.
+ */
+export declare class Filter extends BaseFilter {
+    private _components;
+    private _toggle;
+    private _formComponents;
+    static make(name: string): Filter;
+    /** Filter fields; their names are the only state keys accepted from the browser. */
+    schema(components: unknown[]): this;
+    /** Form fields of a filter without `schema()`: a toggle instead of a checkbox. */
+    toggle(condition?: boolean): this;
+    checkbox(): this;
+    private hasSchema;
     getFormComponents(): unknown[];
+    private fields;
+    getResetState(): FilterState;
+    getDefaultState(): FilterState;
     sanitizeState(state: unknown): FilterState;
+    /** A field left empty, or an unchecked checkbox, does not filter. */
     isActive(state: FilterState): boolean;
     apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
-    getIndicators(state: FilterState): FilterIndicator[];
+    protected defaultIndicators(data: FilterState): IndicatorResult;
     removeIndicator(state: FilterState, field: string): FilterState;
 }
 export type ColumnState = {
@@ -597,9 +1104,59 @@ export type ColumnState = {
     isToggleable: boolean;
     isToggledHiddenByDefault: boolean | null;
 };
+/** Look of a filters action (trigger, apply, reset), changed with `filtersTriggerAction()`, `filtersApplyAction()` and `filtersResetAction()`. */
+export declare class FiltersAction {
+    private _label;
+    private _icon;
+    private _color;
+    private _view;
+    private _hidden;
+    label(label: string | null): this;
+    icon(icon: string | null): this;
+    color(color: string | null): this;
+    /** Labeled button. */
+    button(): this;
+    link(): this;
+    /** Icon only, the label becomes the tooltip and accessible name. */
+    iconButton(): this;
+    hidden(condition?: boolean): this;
+    resolve(defaults: {
+        label: string;
+        icon: string | null;
+        color: string;
+        view: 'button' | 'link' | 'icon-button';
+    }): {
+        label: string;
+        icon: string;
+        color: string;
+        view: "link" | "button" | "icon-button";
+        hidden: boolean;
+    };
+}
+type FiltersActionView = ReturnType<FiltersAction['resolve']> & {
+    customized: boolean;
+};
+/** Bulk actions grouped in the "Bulk actions" dropdown of the toolbar (`toolbarActions([BulkActionGroup.make([...])])`). */
+export declare class BulkActionGroup {
+    private _actions;
+    constructor(actions: any[]);
+    static make(actions: any[]): BulkActionGroup;
+    getActions(): any[];
+}
+/** Upper bound on the rows loaded by an unpaginated table or the `'all'` page option. */
+export declare const MAX_UNPAGINATED_RECORDS = 10000;
 export declare class Table<R = any> {
+    /** Default setup for every table, e.g. `Table.configureUsing((table) => table.paginationPageOptions([10, 25]))`. */
+    static configureUsing(configure: (table: Table<any>) => void): void;
+    constructor();
     private _columns;
     private _recordAction;
+    private _pageSummary;
+    private _allTableSummary;
+    /** Which summary rows to show: "this page" (`pageCondition`) and the whole table (`allTableCondition`); group summaries are not affected. */
+    summaries(pageCondition?: boolean, allTableCondition?: boolean): this;
+    hasPageSummary(): boolean;
+    hasAllTableSummary(): boolean;
     private _recordActions;
     private _heading;
     private _headerActions;
@@ -610,6 +1167,12 @@ export declare class Table<R = any> {
     private _defaultSort;
     private _recordUrl;
     private _pageOptions;
+    private _paginated;
+    private _emptyStateHeading;
+    private _emptyStateDescription;
+    private _emptyStateIcon;
+    private _emptyStateActions;
+    private _emptyState;
     private _stackedOnMobile;
     private _label;
     private _groups;
@@ -651,8 +1214,14 @@ export declare class Table<R = any> {
     areGroupsCollapsedByDefault(): boolean;
     private _columnsLayout;
     columns(columns: (Column<R> | ColumnGroup<R> | ColumnLayout<R>)[]): this;
-    /** Column layout, or `null` for a regular table. */
+    /** Column layout, or `null` for a regular table. The collapsible component is left out (see `getCollapsibleColumnsLayout()`). */
     getColumnsLayout(): (Column<R> | ColumnLayout<R>)[] | null;
+    /** The first top-level layout component marked `collapsible()`, shown behind a toggle button. */
+    getCollapsibleColumnsLayout(): ColumnLayout<R> | null;
+    private _contentGrid;
+    /** Arranges the record cards of a column layout in a grid: `contentGrid({ md: 2, xl: 3 })`. */
+    contentGrid(columns: Record<string, number> | number | null): this;
+    getContentGrid(): Record<string, number> | null;
     /** Action mounted when a row is clicked (e.g. `'edit'`), instead of a URL. */
     recordAction(name: string | null): this;
     getRecordAction(): string | null;
@@ -664,10 +1233,18 @@ export declare class Table<R = any> {
     getHeaderActions(): any[];
     /** Bulk actions ("Bulk actions" menu); if never called, the host provides its default ones. */
     groupedBulkActions(actions: any[]): this;
+    /** Bulk actions: those of `groupedBulkActions()`, then those of the `BulkActionGroup`s of `toolbarActions()`; `null` when none is declared. */
     getBulkActions(): any[] | null;
+    private _toolbarActions;
+    /** Actions in the toolbar, left of the search field: buttons, and a `BulkActionGroup` for the bulk actions dropdown. */
+    toolbarActions(actions: any[]): this;
+    /** Toolbar actions other than bulk action groups. */
+    getToolbarActions(): any[];
     /** Row actions: `Action`s or an `ActionGroup` (dropdown). */
     recordActions(actions: any[]): this;
     getRecordActions(): any[];
+    /** Actions given to columns with `action()` (not those named after a record action). */
+    getColumnActions(): any[];
     /** CSS classes added to a row depending on its record. */
     recordClasses(resolver: (record: R) => string | null): this;
     getRecordClasses(record: R): string | null;
@@ -676,19 +1253,110 @@ export declare class Table<R = any> {
     }): this;
     filtersLayout(layout: FiltersLayout): this;
     getFiltersLayout(): FiltersLayout;
-    /** No-op kept for API compatibility: filters always wait for the "Apply" button. */
-    deferFilters(): this;
+    private _deferFilters;
+    private _filtersFormColumns;
+    private _filtersFormWidth;
+    private _filtersFormMaxHeight;
+    private _filtersResetPosition;
+    private _filterIndicatorsHidden;
+    private _persist;
+    private _recordActionsPosition;
+    private _recordActionsAlignment;
+    /**
+     * Where row actions go: after the columns (default), before the columns (after the checkbox), or before the checkbox
+     * (`before-cells`). `after-cells` is the same as `after-columns`.
+     */
+    recordActionsPosition(position: 'before-columns' | 'before-cells' | 'after-columns' | 'after-cells'): this;
+    getRecordActionsPosition(): 'before-columns' | 'before-cells' | 'after-columns' | 'after-cells';
+    /** Alignment of row actions in their cell. */
+    recordActionsAlignment(alignment: 'start' | 'center' | 'end' | null): this;
+    getRecordActionsAlignment(): 'start' | 'center' | 'end' | null;
+    private _isRecordSelectable;
+    private _maxSelectableRecords;
+    private _selectsCurrentPageOnly;
+    /** Records for which this returns `false` have no checkbox, and are ignored by bulk actions even if the browser sends them. */
+    checkIfRecordIsSelectableUsing(callback: ((record: R) => boolean | Promise<boolean>) | null): this;
+    hasRecordSelectabilityCheck(): boolean;
+    isRecordSelectable(record: R): Promise<boolean>;
+    /** Maximum number of records the user may select at once (also enforced on the server). */
+    maxSelectableRecords(count: number | null): this;
+    getMaxSelectableRecords(): number | null;
+    /** "Select all" only selects the records of the current page. */
+    selectCurrentPageOnly(condition?: boolean): this;
+    selectsCurrentPageOnly(): boolean;
+    /** `false`: filters apply as soon as a field changes, without the "Apply" button. */
+    deferFilters(condition?: boolean): this;
+    private _filterActions;
+    /** Customizes the button that opens the filters: `filtersTriggerAction((action) => action.button().label('Filter'))`. */
+    filtersTriggerAction(configure: (action: FiltersAction) => FiltersAction | void): this;
+    /** Customizes the "Apply" button of deferred filters. */
+    filtersApplyAction(configure: (action: FiltersAction) => FiltersAction | void): this;
+    /** Customizes the "Reset" button (`hidden()` removes it). */
+    filtersResetAction(configure: (action: FiltersAction) => FiltersAction | void): this;
+    getFiltersActionView(kind: 'trigger' | 'apply' | 'reset'): FiltersActionView;
+    private _filtersFormSchema;
+    /**
+     * Arranges the filters form yourself: the function receives each filter's form group, keyed by filter name, and returns
+     * the form components (e.g. sections). Filters left out are not shown.
+     */
+    filtersFormSchema(schema: ((filters: Record<string, any>) => any[]) | null): this;
+    getFiltersFormSchema(): ((filters: Record<string, any>) => any[]) | null;
+    hasDeferredFilters(): boolean;
+    /** Columns of the filters form grid (1 in a dropdown or modal, up to 5 above or below the content by default). */
+    filtersFormColumns(columns: number | Record<string, number> | null): this;
+    getFiltersFormColumns(): number | Record<string, number>;
+    /** Width of the filters dropdown, modal or side panel: `xs` to `7xl`, `full`, `screen`... */
+    filtersFormWidth(width: string | null): this;
+    getFiltersFormWidth(): string | null;
+    /** Maximum height of the filters dropdown, as a CSS length; it scrolls beyond. */
+    filtersFormMaxHeight(height: string | null): this;
+    getFiltersFormMaxHeight(): string | null;
+    /** `footer`: the "Reset" button goes next to "Apply" instead of the filters heading. */
+    filtersResetActionPosition(position: 'header' | 'footer'): this;
+    getFiltersResetActionPosition(): 'header' | 'footer';
+    /** Hides the active filter badges above the table. */
+    hiddenFilterIndicators(condition?: boolean): this;
+    areFilterIndicatorsHidden(): boolean;
+    /** Keeps the applied filters for the user's browser session (restored when the page is opened again). */
+    persistFiltersInSession(condition?: boolean): this;
+    persistSearchInSession(condition?: boolean): this;
+    persistColumnSearchesInSession(condition?: boolean): this;
+    persistSortInSession(condition?: boolean): this;
+    private _persistGrouping;
+    persistGroupingInSession(condition?: boolean): this;
+    persistsGroupingInSession(): boolean;
+    persistsFiltersInSession(): boolean;
+    persistsSearchInSession(): boolean;
+    persistsColumnSearchesInSession(): boolean;
+    persistsSortInSession(): boolean;
     defaultSort(column: string, direction?: SortDirection): this;
     recordUrl(resolver: (record: R) => string | null): this;
     private _reorderColumn;
     /** Lets users reorder rows by hand; `column` stores the position. */
     reorderable(column: string | null): this;
     getReorderColumn(): string | null;
-    paginationPageOptions(options: number[]): this;
+    /** Page sizes offered; `'all'` shows every record (up to `MAX_UNPAGINATED_RECORDS`). */
+    paginationPageOptions(options: (number | 'all')[]): this;
+    /** `false`: no pagination, every record is shown (up to `MAX_UNPAGINATED_RECORDS`). An array sets the page options. */
+    paginated(condition?: boolean | (number | 'all')[]): this;
+    isPaginated(): boolean;
+    /** Heading of the empty state, instead of "No <records>". */
+    emptyStateHeading(heading: string | (() => string) | null): this;
+    emptyStateDescription(description: string | (() => string | null) | null): this;
+    emptyStateIcon(icon: string | null): this;
+    /** Actions shown in the empty state, e.g. a create action. They are mounted like table header actions. */
+    emptyStateActions(actions: any[]): this;
+    getEmptyStateActions(): any[];
+    /** Replaces the whole empty state with your HTML (inserted as it is: escape your data with `e()`). */
+    emptyState(html: string | (() => string | Promise<string>) | null): this;
+    getEmptyStateHeading(): string;
+    getEmptyStateDescription(): string | null;
+    getEmptyStateIcon(): string;
+    getCustomEmptyState(): Promise<string | null>;
     private _defaultPageOption;
     /** Rows per page when the table opens. */
-    defaultPaginationPageOption(option: number | null): this;
-    getDefaultPageOption(): number;
+    defaultPaginationPageOption(option: number | 'all' | null): this;
+    getDefaultPageOption(): number | 'all';
     private _paginationMode;
     /** `'simple'`: previous / next buttons only, without page numbers or total. */
     paginationMode(mode: 'default' | 'simple'): this;
@@ -703,7 +1371,7 @@ export declare class Table<R = any> {
         direction: SortDirection;
     } | null;
     getRecordUrl(record: R): string | null;
-    getPageOptions(): number[];
+    getPageOptions(): (number | 'all')[];
     isStackedOnMobile(): boolean;
     getPluralModelLabel(): string;
     hasToggleableColumns(): boolean;
@@ -717,7 +1385,7 @@ export interface TableHost {
     tableSearch: string;
     tableSort: string | null;
     tableColumnSearches: Record<string, string>;
-    tableRecordsPerPage: number;
+    tableRecordsPerPage: number | 'all';
     paginators: Record<string, number>;
     tableFilters?: Record<string, FilterState>;
     tableColumns?: ColumnState[];
@@ -749,6 +1417,10 @@ export declare function getFilterIndicators<R>(table: Table<R>, host: TableHost)
     field: string;
     label: string;
 }[];
+/** Whether an applied filter can be removed: none of its indicators is marked `removable(false)`. */
+export declare function isTableFilterRemovable<R>(table: Table<R>, host: TableHost, filterName: string): Promise<boolean>;
+/** Keys whose record passes `checkIfRecordIsSelectableUsing()`, loaded in chunks. Without a check, the keys are returned as they are. */
+export declare function filterSelectableKeys<R>(table: Table<R>, adapter: Pick<DataAdapter<R>, 'find'>, keys: string[], chunkSize?: number): Promise<string[]>;
 /** Cycles a column's sort: none → asc → desc → none. */
 export declare function sortTable(host: TableHost, column?: string | null, direction?: string | null): void;
 /** Loads the page of records matching the host's state. */
@@ -774,6 +1446,10 @@ export type RenderTableOptions<R> = {
     after?: string;
     /** Already rendered HTML of the table header actions. */
     headerActions?: string[];
+    /** Already rendered HTML of the toolbar actions. */
+    toolbarActions?: string[];
+    /** Already rendered HTML of the empty state actions. */
+    emptyStateActions?: string[];
     /** Already rendered HTML of the row actions (ActionGroup…), replacing the `rowActions` links. */
     rowActionsHtml?: (record: R) => Promise<string>;
     bulkActions?: string[];