@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-table.d.ts

@@ -0,0 +1,888 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, TableMessages } from '@slotted/core/i18n';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor } from '@angular/forms';
+import { OverflowState } from '@slotted/core/overflow';
+import { PlainDate, TimeGranularity, PlainDateTime, PlainTime } from '@slotted/core/date';
+import { FilterKind, FilterDescriptor, FilterJoin, FilterCondition, BooleanFilter, DateFilter, DateTimeFilter, NumberFilter, SetFilter, TextFilter, TimeFilter } from '@slotted/core/filter';
+import * as _slotted_angular_table from '@slotted/angular/table';
+import * as i1 from '@slotted/angular/tooltip';
+
+/** How much of a frame the set is given. The vocabulary `description-list` set. */
+type TableVariant = 'plain' | 'ruled' | 'framed';
+/**
+ * Whether the browser sizes the columns from their content or from what the
+ * table states. `fixed` is what makes a stated width hold and a truncated cell
+ * truncate at all.
+ */
+type TableLayout = 'auto' | 'fixed';
+type TableSelectionMode = 'none' | 'single' | 'multiple';
+/**
+ * What a sticky header stays inside: the family's own scroller, or whatever
+ * scrolls outside it — the page, an app shell, a scroll area.
+ */
+type TableStickyTo = 'scroll' | 'page';
+/** Which edge a cell's content stands on, resolved logically. */
+type TableAlign = 'start' | 'center' | 'end';
+/** What a value longer than its column does. None of the three removes it. */
+type TableText = 'wrap' | 'truncate' | 'nowrap';
+/** Which edge a column is pinned to while the table scrolls past it. */
+type TableSticky = 'start' | 'end';
+type TableSortDirection = 'ascending' | 'descending';
+/**
+ * Which column the rows are ordered by, and which way. The family holds it and
+ * reorders nothing: the rows are the consumer's own, written in the template,
+ * so the consumer applies the descriptor to its own array or its own query.
+ */
+interface TableSortDescriptor {
+    column: string;
+    direction: TableSortDirection;
+}
+type TableSortReason = 'pointer' | 'keyboard' | 'clear' | 'programmatic';
+type TableSelectionReason = 'pointer' | 'keyboard' | 'select' | 'clear' | 'programmatic';
+type TableExpandedReason = 'pointer' | 'keyboard' | 'programmatic';
+interface TableDefaults {
+    cellAlign: TableAlign;
+    columns: number;
+    layout: TableLayout;
+    selectionMode: TableSelectionMode;
+    stickyFooter: boolean;
+    stickyHeader: boolean;
+    stickyTo: TableStickyTo;
+    striped: boolean;
+    variant: TableVariant;
+}
+declare const TABLE_DEFAULTS: InjectionToken<TableDefaults>;
+/**
+ * An application decides once how its tables are framed and how they select,
+ * rather than repeating the same inputs on every listing screen. A table that
+ * states any of them itself still wins. Its words come from the language in
+ * force (`provideSlotted`).
+ */
+declare function provideTableDefaults(defaults: Partial<TableDefaults>): {
+    provide: InjectionToken<TableDefaults>;
+    useFactory: () => TableDefaults;
+};
+declare function injectTableDefaults(): TableDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * a module-level counter produces colliding sequences when two applications
+ * render in one server process, and the server and the client sequences must
+ * match for hydration.
+ */
+declare class SlTableIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/** Every selectable row, in the order the body renders them. */
+declare const TABLE_ROW_SELECTOR = "[data-part=\"body\"] > [data-part=\"row\"][data-value]";
+/**
+ * A table of moderate data: the platform's own structure, with sorting,
+ * selection, expansion and a place for a paging control.
+ *
+ * **The role is `table`, not `grid`.** The APG is explicit — a table "is not an
+ * interactive widget. Thus, its cells are not focusable or selectable" — so
+ * every control inside it is its own tab stop and the family binds no key of
+ * its own. `data-grid` is the composite widget with a cell cursor.
+ *
+ * **The family holds the sort and reorders nothing.** The rows are the
+ * consumer's own, written with `@for` over their own array; reordering them
+ * would mean owning the data, which is the line between this family and
+ * `data-grid`.
+ *
+ * **The selection is a form value.** A bulk-action screen is a reactive form
+ * rather than a component with a callback, which no surveyed Angular table
+ * offers.
+ */
+declare class SlTable implements ControlValueAccessor {
+    /** Which column the rows are ordered by. Two-way, so a template binds it. */
+    readonly sort: _angular_core.ModelSignal<TableSortDescriptor | null>;
+    /** The chosen rows, in the collection's own order. */
+    readonly value: _angular_core.ModelSignal<readonly string[]>;
+    /** The rows whose detail is open. */
+    readonly expanded: _angular_core.ModelSignal<readonly string[]>;
+    readonly variant: _angular_core.InputSignal<TableVariant | undefined>;
+    readonly layout: _angular_core.InputSignal<TableLayout | undefined>;
+    readonly selectionMode: _angular_core.InputSignal<TableSelectionMode | undefined>;
+    /**
+     * Where every cell's content sits in a row as tall as its tallest cell. A
+     * cell states `blockAlign` to answer differently.
+     */
+    readonly cellAlign: _angular_core.InputSignal<TableAlign | undefined>;
+    readonly striped: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly stickyHeader: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Holds the summary rows against the bottom of the same box the header is
+     * held against the top of, so a total does not scroll out of the view that
+     * exists to show it. It pins the `tfoot` and not the footer bar, which is
+     * outside the scroller and never leaves.
+     */
+    readonly stickyFooter: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * What the sticky header stays inside. `page` releases the family's own
+     * scroll container, so the table can no longer scroll sideways in its frame.
+     */
+    readonly stickyTo: _angular_core.InputSignal<TableStickyTo | undefined>;
+    /**
+     * How many columns the table renders. The spanning parts — the detail row,
+     * the empty cell, the skeleton rows — need the number, and reading it from
+     * the DOM would be nothing on the server and a count on the client.
+     */
+    readonly columns: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** A refresh over rows already shown: `aria-busy`, and nothing moves. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * selection, expansion and sort words, the scrolling region's name and every
+     * word of the column filters.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<TableMessages> | undefined>;
+    /** One output per transition, each carrying the reason and the event. */
+    readonly sortChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<TableSortDescriptor | null>>;
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    readonly expandedChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    private readonly defaults;
+    private readonly host;
+    readonly id: string;
+    /** Where a range starts: the row of the last press that held no modifier. */
+    private anchor;
+    private touched;
+    private notify;
+    private readonly formDisabled;
+    readonly resolvedVariant: _angular_core.Signal<TableVariant>;
+    readonly resolvedLayout: _angular_core.Signal<TableLayout>;
+    readonly resolvedCellAlign: _angular_core.Signal<TableAlign>;
+    readonly resolvedMode: _angular_core.Signal<TableSelectionMode>;
+    readonly resolvedStriped: _angular_core.Signal<boolean>;
+    readonly resolvedStickyHeader: _angular_core.Signal<boolean>;
+    readonly resolvedStickyFooter: _angular_core.Signal<boolean>;
+    readonly resolvedStickyTo: _angular_core.Signal<TableStickyTo>;
+    readonly resolvedColumns: _angular_core.Signal<number>;
+    /** The family's words in the language in force, with this table's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<TableMessages>;
+    isSelected(key: string): boolean;
+    isExpanded(key: string): boolean;
+    /**
+     * Every selectable row's value, read out of the DOM at the moment it is
+     * needed rather than kept in a registry. A registry holds the order rows were
+     * created in, and a sorted table renders the same rows in a new order without
+     * destroying one of them — so the range and the select-all would run against
+     * the order before the sort.
+     */
+    rows(): readonly string[];
+    requestSort(column: string, source: Event | undefined): void;
+    toggleSelected(key: string, options: {
+        range: boolean;
+        source: Event | undefined;
+    }): void;
+    toggleSelectAll(source: Event | undefined): void;
+    toggleExpanded(key: string, source: Event | undefined): void;
+    /** The form's own value is the selection, which is what a bulk action acts on. */
+    writeValue(value: readonly string[] | null | undefined): void;
+    registerOnChange(fn: (value: readonly string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    readonly disabledByForm: _angular_core.Signal<boolean>;
+    private requestValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTable, "div[slTable]", ["slTable"], { "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "cellAlign": { "alias": "cellAlign"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "stickyFooter": { "alias": "stickyFooter"; "required": false; "isSignal": true; }; "stickyTo": { "alias": "stickyTo"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; "value": "valueChange"; "expanded": "expandedChange"; "sortChangeRequest": "sortChangeRequest"; "valueChangeRequest": "valueChangeRequest"; "expandedChangeRequest": "expandedChangeRequest"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The scroller and the table it holds.
+ *
+ * Two elements and one component, because neither is a decision a consumer
+ * makes: the `table` carries the semantics and the host carries the overflow.
+ * Angular pays one element for the host and draws the other in its template,
+ * which is the same division `checkbox` records.
+ *
+ * **The region wiring is written only while the table overflows.** `role`,
+ * `tabindex` and a name arrive together, measured by `@slotted/core/overflow` —
+ * the rule `prose` set. A tab stop on a table that fits makes a reader press Tab
+ * for nothing, and a wide table with no tab stop is unreachable without a
+ * pointer. Nothing is measured until the first render after mount, so the
+ * server renders a plain scroller and hydration finds the same DOM.
+ *
+ * **The host's `aria-label` names the table.** An instance with no caption
+ * names itself with it, and the template writes it on the `table`, the
+ * element whose name it is. The region takes the catalog's name, or
+ * `scrollLabel`.
+ */
+declare class SlTableContent {
+    /**
+     * The total number of rows behind a paged or filtered table. Written as
+     * `aria-rowcount`, with `aria-rowindex` on every row, and only then: the
+     * practice requires the pair exactly when the DOM is not the whole set.
+     */
+    readonly totalRowCount: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** The name the region takes while it overflows, over the catalog's. */
+    readonly scrollLabel: _angular_core.InputSignal<string | undefined>;
+    /** The element that names it instead, which is usually the caption. */
+    readonly scrollLabelledBy: _angular_core.InputSignal<string | undefined>;
+    readonly table: SlTable;
+    private readonly host;
+    /** The host's own `aria-label`: the table's name, moved onto the `table`. */
+    protected readonly tableLabel: string | null;
+    private affordance;
+    readonly state: _angular_core.WritableSignal<OverflowState>;
+    readonly regionLabel: _angular_core.Signal<string | null>;
+    readonly regionLabelledBy: _angular_core.Signal<string | null>;
+    constructor();
+    /** Brings one row into view by the shortest movement that does it. */
+    scrollToRow(value: string): void;
+    /** Measures again, after rows arrive or a column changes width. */
+    refresh(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableContent, "div[slTableContent]", ["slTableContent"], { "totalRowCount": { "alias": "totalRowCount"; "required": false; "isSignal": true; }; "scrollLabel": { "alias": "scrollLabel"; "required": false; "isSignal": true; }; "scrollLabelledBy": { "alias": "scrollLabelledBy"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** One value a column can be filtered to. */
+interface TableFilterOption {
+    /** The value the consumer's query matches. It is what the state holds. */
+    value: string;
+    /** What the reader sees, when it is not the value itself. */
+    label?: string;
+    /**
+     * How many records carry it. Optional and the consumer's own: how many rows a
+     * value has is a fact about the query, not about the column.
+     */
+    count?: number;
+}
+type TableFilterReason = 'pointer' | 'keyboard' | 'clear' | 'programmatic';
+type Condition = FilterCondition<string, unknown>;
+/** What the operand template is handed, once per condition. */
+interface TableFilterOperandContext {
+    /** Applies the draft, which is what `Enter` in the family's own field does. */
+    apply: () => void;
+    condition: Condition;
+    /** The name the family would have given each field. */
+    label: (slot: 0 | 1) => string;
+    /** Writes one operand back into the draft. */
+    set: (slot: 0 | 1, value: unknown) => void;
+    /**
+     * Writes both operands of a range at once, for a control that holds both.
+     * Two calls to `set` from one event would each read the draft the other did
+     * not write.
+     */
+    setBoth: (value: unknown, end: unknown) => void;
+    /** Which operands this operator takes: none, the first, or both. */
+    slots: readonly (0 | 1)[];
+}
+/**
+ * Everything the five filters share: the draft, the conditions, the join, the
+ * announcements and the request that carries a reason. What each of them adds
+ * is its kind, its own typed `value`, and the control inside `filter-operand`.
+ *
+ * The panel edits a **draft**. Nothing reaches the consumer until Apply, and
+ * Escape or a press outside restores the descriptor the panel opened with. The
+ * family applies nothing: it reports the descriptor, and
+ * `createFilterPredicate` in `@slotted/core/filter` is what a consumer applies
+ * to its own rows.
+ */
+declare abstract class SlTableFilterBase {
+    /** Which vocabulary this column's conditions are written in. */
+    abstract readonly kind: FilterKind;
+    /** The committed descriptor, read from the component's own typed model. */
+    protected abstract readValue(): FilterDescriptor | null;
+    /** Writes it back into that model. */
+    protected abstract writeValue(next: FilterDescriptor | null): void;
+    /**
+     * The operators this column offers, narrowing the kind's own list. Declared
+     * once here rather than per component: the narrow operator type is the one
+     * thing a shared base cannot keep, and the value — which is what a consumer
+     * reads — stays exact on each of the five.
+     */
+    readonly operators: _angular_core.InputSignal<readonly string[] | undefined>;
+    /** Which one the panel opens on. The kind's own default unless stated. */
+    readonly defaultOperator: _angular_core.InputSignal<string | undefined>;
+    /**
+     * How many conditions the panel offers, which is AG Grid's
+     * `maxNumConditions`. The second appears once the first is complete.
+     */
+    readonly conditions: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * The column's name in the trigger's own name. Read from the column header
+     * around it when it is not stated.
+     */
+    readonly columnLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The trigger's whole accessible name, replacing the one the catalog writes.
+     * It is the trigger's `aria-label`, which no other input reaches.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the panel is drawn at the end of the document. On by default, and
+     * that is not a preference: a framed table clips its own overflow, so an
+     * unportalled panel is cut off at the frame's edge — read on the Angular
+     * reference page, where the join and both actions were simply not there. The
+     * React binding takes `popover`'s own default, which is the same answer.
+     */
+    readonly portal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The request behind every committed change, with the reason it carries. */
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<FilterDescriptor | null>>;
+    readonly table: SlTable;
+    private readonly header;
+    private readonly host;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly draft: _angular_core.WritableSignal<FilterDescriptor>;
+    /** The table's words, which the panel speaks in. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<_slotted_core_i18n.TableMessages>;
+    protected readonly start: _angular_core.Signal<string>;
+    readonly offered: _angular_core.Signal<readonly string[]>;
+    private readonly format;
+    operatorName(operator: string): string;
+    /** Every operator as a labelled option, so the closed chooser names its own. */
+    readonly operatorItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    joinName(join: FilterJoin): string;
+    readonly filtered: _angular_core.Signal<boolean>;
+    readonly name: _angular_core.Signal<string>;
+    /** One condition, or the two the panel can hold. */
+    readonly rows: _angular_core.Signal<readonly Condition[]>;
+    protected allowed(): number;
+    readonly hasSecond: _angular_core.Signal<boolean>;
+    /**
+     * Whether the operand template draws one control for both ends of a range,
+     * written as `data-range` on `filter-operand` so the two-column operand grid
+     * collapses to one. The date, time and date-time filters say yes.
+     */
+    protected rangeOperand(): boolean;
+    /** Which of a kind's operands is drawn, written as `data-operand`. */
+    operandName(): string | null;
+    /** `data-range`, for the condition whose operator takes two operands. */
+    rangeMark(condition: Condition): '' | null;
+    slotsOf(condition: Condition): readonly (0 | 1)[];
+    operandLabel(condition: Condition, slot: 0 | 1): string;
+    context(index: number): TableFilterOperandContext;
+    announce(message: string): void;
+    /**
+     * Opens and closes, and resets the draft either way: the draft starts from
+     * what is committed every time the panel opens, and closing puts it back —
+     * closing is cancelling, and Apply closes the panel itself after committing.
+     */
+    toggle(next: boolean): void;
+    protected blank(): FilterDescriptor;
+    setOperator(index: number, operator: string): void;
+    setOperand(index: number, slot: 0 | 1, operand: unknown): void;
+    setOperands(index: number, value: unknown, end: unknown): void;
+    setJoin(join: string): void;
+    /**
+     * Named for what it does rather than `apply`, which reads as
+     * `Function.prototype.apply` to a linter and to the next reader after it.
+     */
+    applyDraft(source: unknown, reason?: TableFilterReason): void;
+    clear(source: unknown): void;
+    readonly canClear: _angular_core.Signal<boolean>;
+    private columnName;
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableFilterBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableFilterBase, never, never, { "operators": { "alias": "operators"; "required": false; "isSignal": true; }; "defaultOperator": { "alias": "defaultOperator"; "required": false; "isSignal": true; }; "conditions": { "alias": "conditions"; "required": false; "isSignal": true; }; "columnLabel": { "alias": "columnLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "portal": { "alias": "portal"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "valueChangeRequest": "valueChangeRequest"; "open": "openChange"; }, never, never, true, never>;
+}
+/**
+ * The panel every kind shares, drawn around an operand its owner projects.
+ *
+ * The operand is an `ng-template` rather than projected content, because it is
+ * rendered once per condition: content would be built once and then belong to
+ * whichever condition asked for it first.
+ */
+declare class SlTableFilterShell {
+    /** The filter this shell draws for. */
+    readonly owner: _angular_core.InputSignal<SlTableFilterBase>;
+    /** The control inside `filter-operand`, rendered once per condition. */
+    readonly operand: _angular_core.InputSignal<TemplateRef<{
+        $implicit: TableFilterOperandContext;
+    }>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableFilterShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableFilterShell, "span[slTableFilterShell]", ["slTableFilterShell"], { "owner": { "alias": "slTableFilterShell"; "required": true; "isSignal": true; }; "operand": { "alias": "operand"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** A column of words. Its comparisons are the collator's, never a fold. */
+declare class SlTableTextFilter extends SlTableFilterBase {
+    readonly kind: "text";
+    /** The filter the column holds. Two-way, so a template binds it. */
+    readonly value: _angular_core.ModelSignal<TextFilter | null>;
+    protected readValue(): TextFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableTextFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableTextFilter, "span[slTableTextFilter]", ["slTableTextFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+/** A column of quantities. The operand parses in the reader's own locale. */
+declare class SlTableNumberFilter extends SlTableFilterBase {
+    readonly kind: "number";
+    readonly value: _angular_core.ModelSignal<NumberFilter | null>;
+    /** BCP 47, for the operand's own parsing. Defaults to the runtime's. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    protected readValue(): NumberFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableNumberFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableNumberFilter, "span[slTableNumberFilter]", ["slTableNumberFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * A column of days. The operand is the whole date picker — the segmented field
+ * and the calendar behind it — rather than the field alone: every surveyed
+ * implementation that filters a date column offers a grid to point at, and a
+ * reader who has to type a date they could have pointed at is the one thing a
+ * date filter exists to spare them. The calendar opens a layer inside the
+ * panel's layer, which `dismissable-layer` already stacks for the operator
+ * chooser beside it.
+ *
+ * `between` is one `date-range-picker` rather than two pickers: it says the
+ * run's length while it is drawn, takes the ends in either order and carries
+ * the application's own presets. The descriptor holds the ISO days the
+ * pickers produce, never a `Date`, and is the same object either way.
+ */
+declare class SlTableDateFilter extends SlTableFilterBase {
+    readonly kind: "date";
+    readonly value: _angular_core.ModelSignal<DateFilter | null>;
+    /** BCP 47. Decides the operand's field order and separators. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The application's own ranges — this week, this month — as
+     * `slDateRangePickerPreset` buttons in a template, offered inside the range
+     * picker `between` draws. The descriptor still receives two ISO days.
+     */
+    readonly presets: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    protected rangeOperand(): boolean;
+    /** The descriptor's ISO day as the field's own value, and back. */
+    day(value: unknown): PlainDate | null;
+    iso(value: unknown): string | null;
+    range(condition: Condition): {
+        start: PlainDate | null;
+        end: PlainDate | null;
+    };
+    protected readValue(): DateFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableDateFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableDateFilter, "span[slTableDateFilter]", ["slTableDateFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * A column of times of day. The operand is `time-picker` — the segmented field
+ * and the list behind it — at the column's own granularity, which decides the
+ * precision the descriptor is written at and the engine compares at: a picker
+ * writing minutes produces `09:14`, and `is 09:14` then matches every second
+ * of that minute.
+ *
+ * `between` is one `time-range-picker` rather than two pickers: it says the
+ * run's length while it is drawn, its end list refuses the times before the
+ * start, and it carries the application's presets. The descriptor is
+ * unchanged. A pair whose start is later than its end is the overnight window
+ * to the engine and `order` to the picker; the pair reaches the descriptor
+ * either way, and the picker's `wrap`, pending in `docs/process/build-order.md`, is
+ * what lifts the mark. No `(keydown.enter)` on the range picker: its frame
+ * is a button, and `Enter` on it opens the picker.
+ */
+declare class SlTableTimeFilter extends SlTableFilterBase {
+    readonly kind: "time";
+    readonly value: _angular_core.ModelSignal<TimeFilter | null>;
+    /** BCP 47. Decides the operand's hour cycle and separators. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Twelve or twenty-four hours, overriding what the locale says. */
+    readonly hourCycle: _angular_core.InputSignal<12 | 24 | undefined>;
+    /** The last unit the operand writes. Minute unless stated. */
+    readonly granularity: _angular_core.InputSignal<TimeGranularity | undefined>;
+    /** The list's step, in seconds. */
+    readonly step: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The list's own entries, replacing the step. */
+    readonly options: _angular_core.InputSignal<readonly PlainTime[] | undefined>;
+    /** The earliest time the operand accepts, as ISO time text. */
+    readonly min: _angular_core.InputSignal<string | undefined>;
+    /** The latest, as ISO time text. */
+    readonly max: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The application's own windows — the morning shift, the night shift — as
+     * `slTimeRangePickerPreset` buttons in a template, offered inside the range
+     * picker `between` draws. The descriptor still receives two ISO times.
+     */
+    readonly presets: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    protected rangeOperand(): boolean;
+    timeOf(value: unknown): PlainTime | undefined;
+    iso(value: unknown): string | null;
+    range(condition: Condition): {
+        start: PlainTime | null;
+        end: PlainTime | null;
+    };
+    protected readValue(): TimeFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableTimeFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableTimeFilter, "span[slTableTimeFilter]", ["slTableTimeFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * A column of dates with times. The operand is `datetime-picker`, the
+ * seven-segment field and the two surfaces behind it. A value with one half
+ * missing reaches the draft as no operand at all, so the condition stays
+ * inactive until both halves exist — the engine's one rule for a missing
+ * operand, and the reason Apply reports nothing for a date without a time.
+ *
+ * `between` is one `datetime-range-picker`: the run's length said while it is
+ * drawn, the dates ordered with each time kept on its end, and the
+ * application's presets. No `(keydown.enter)` on it: the frame is a button,
+ * and `Enter` on it opens the picker.
+ */
+declare class SlTableDateTimeFilter extends SlTableFilterBase {
+    readonly kind: "datetime";
+    readonly value: _angular_core.ModelSignal<DateTimeFilter | null>;
+    /** BCP 47. Decides the operand's field order and separators. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** The zone "now" is read in. Defaults to the runtime's. */
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    /** Twelve or twenty-four hours, overriding what the locale says. */
+    readonly hourCycle: _angular_core.InputSignal<12 | 24 | undefined>;
+    /** The last unit the operand writes. Minute unless stated. */
+    readonly granularity: _angular_core.InputSignal<TimeGranularity | undefined>;
+    /** The list's step, in seconds. */
+    readonly step: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The earliest date-time the operand accepts, as ISO date-time text. */
+    readonly min: _angular_core.InputSignal<string | undefined>;
+    /** The latest, as ISO date-time text. */
+    readonly max: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The application's own windows — the last 24 hours, this week — as
+     * `slDateTimeRangePickerPreset` buttons in a template, offered inside the
+     * range picker `between` draws. The descriptor still receives two ISO
+     * date-times.
+     */
+    readonly presets: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    protected rangeOperand(): boolean;
+    dateTimeOf(value: unknown): PlainDateTime | undefined;
+    range(condition: Condition): {
+        start: PlainDateTime | null;
+        end: PlainDateTime | null;
+    };
+    iso(value: unknown): string | null;
+    protected readValue(): DateTimeFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableDateTimeFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableDateTimeFilter, "span[slTableDateTimeFilter]", ["slTableDateTimeFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * A column of yes and no. Three answers rather than two: the third is not being
+ * filtered at all, which is what Clear leaves and what an empty draft is.
+ */
+declare class SlTableBooleanFilter extends SlTableFilterBase {
+    readonly kind: "boolean";
+    readonly value: _angular_core.ModelSignal<BooleanFilter | null>;
+    answer(value: unknown): string;
+    protected readValue(): BooleanFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableBooleanFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableBooleanFilter, "span[slTableBooleanFilter]", ["slTableBooleanFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+/**
+ * A column filtered to values the consumer named: the list, its search and the
+ * checkbox that covers what the search left.
+ *
+ * One condition, and the design says why: `anyOf A and anyOf B` is
+ * `anyOf (A ∩ B)`, so every pair of set conditions collapses to a single list.
+ */
+declare class SlTableSetFilter extends SlTableFilterBase {
+    readonly kind: "set";
+    readonly value: _angular_core.ModelSignal<SetFilter | null>;
+    /**
+     * How the values are chosen. `list` is the search, the covering checkbox and
+     * the values; `tags` is `tags-input`, for a list too long to tick — the
+     * chosen values are chips, and `options` become a datalist of suggestions
+     * and the set a typed value must belong to. The descriptor is the same list
+     * either way.
+     */
+    readonly operand: _angular_core.InputSignal<"list" | "tags">;
+    /**
+     * The values this column can be filtered to, and optionally their counts.
+     * Optional with `tags`, where a column may hold more values than a page
+     * knows; without it any typed value is admitted.
+     */
+    readonly options: _angular_core.InputSignal<readonly TableFilterOption[]>;
+    /**
+     * Whether the panel carries a search. Unstated, it appears once there are
+     * `searchThreshold` values.
+     */
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** How many values bring the search with them. Eight unless stated. */
+    readonly searchThreshold: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly query: _angular_core.WritableSignal<string>;
+    readonly listId: string;
+    operandName(): "list" | "tags";
+    /** Whether a typed value has to be one of the options. */
+    readonly constrained: _angular_core.Signal<boolean>;
+    private readonly byValue;
+    /** The chip's text for a value, and the judgement on a typed one. */
+    readonly optionLabel: (value: string) => string;
+    readonly known: (text: string) => boolean;
+    applyOnEmpty(event: Event, context: TableFilterOperandContext): void;
+    /**
+     * The collator `combobox` filters its own options with, rather than a fold
+     * that strips combining marks: `normalize('NFD')` is an English answer
+     * wearing a Unicode one — it turns `ø` into `ø` and leaves `ß` alone.
+     */
+    private readonly compare;
+    /** Two set conditions collapse to one list, so the panel offers one. */
+    protected allowed(): number;
+    /** What the search left. The covering checkbox answers for exactly this. */
+    readonly shown: _angular_core.Signal<readonly TableFilterOption[]>;
+    readonly searching: _angular_core.Signal<boolean>;
+    chosen(context: TableFilterOperandContext): readonly string[];
+    private covered;
+    allCovered(context: TableFilterOperandContext): boolean;
+    someCovered(context: TableFilterOperandContext): boolean;
+    search(event: Event): void;
+    hold(context: TableFilterOperandContext, value: string, next: boolean): void;
+    coverAll(context: TableFilterOperandContext, next: boolean): void;
+    protected readValue(): SetFilter | null;
+    protected writeValue(next: FilterDescriptor | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableSetFilter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableSetFilter, "span[slTableSetFilter]", ["slTableSetFilter"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "operand": { "alias": "operand"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchThreshold": { "alias": "searchThreshold"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * The axes every cell answers, written once. `numeric` and `align` are two facts
+ * rather than one axis: a number is set in tabular figures whichever way it is
+ * aligned, and a right-aligned label is not a number.
+ */
+declare class SlTableCellAxes {
+    readonly align: _angular_core.InputSignal<TableAlign | undefined>;
+    /**
+     * Where this cell's content sits in a row as tall as its tallest cell. The
+     * table states it once through `cellAlign`; this overrides it for the one
+     * cell that wants the other answer.
+     */
+    readonly blockAlign: _angular_core.InputSignal<TableAlign | undefined>;
+    readonly numeric: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly text: _angular_core.InputSignal<TableText | undefined>;
+    readonly sticky: _angular_core.InputSignal<TableSticky | undefined>;
+    /**
+     * Where a pinned column stops, as a CSS length. Nought unless stated: two
+     * columns pinned to the same edge need the second to know how wide the first
+     * is, and the family states that rather than measuring it — measuring would
+     * mean reading the layout during change detection.
+     */
+    readonly stickyOffset: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableCellAxes, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableCellAxes, never, never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "blockAlign": { "alias": "blockAlign"; "required": false; "isSignal": true; }; "numeric": { "alias": "numeric"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The table's name, and the element the platform already associates with it. A
+ * `caption` is the accessible name whether it is read or hidden, so the family
+ * writes no `aria-labelledby` restating what the browser states.
+ */
+declare class SlTableCaption {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableCaption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableCaption, "caption[slTableCaption]", ["slTableCaption"], {}, {}, never, never, true, never>;
+}
+declare class SlTableHead {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableHead, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableHead, "thead[slTableHead]", ["slTableHead"], {}, {}, never, never, true, never>;
+}
+declare class SlTableBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableBody, "tbody[slTableBody]", ["slTableBody"], {}, {}, never, never, true, never>;
+}
+/**
+ * The `tfoot`, which the HTML Standard calls the column summaries of the table.
+ * It is not `slTableFooter`, which is the bar outside the table holding the
+ * consumer's own controls.
+ */
+declare class SlTableSummary {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableSummary, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableSummary, "tfoot[slTableSummary]", ["slTableSummary"], {}, {}, never, never, true, never>;
+}
+/**
+ * The bar under the table and inside its frame, where a paged listing puts its
+ * control. It is a sibling of the scroller rather than a child, so a table
+ * scrolled sideways does not take its pagination with it.
+ */
+declare class SlTableFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableFooter, "div[slTableFooter]", ["slTableFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * One record. It carries `data-selected` and `data-expanded` for the stylesheet
+ * and `data-value` for the range and the select-all, which read the rows out of
+ * the DOM at the moment they act.
+ *
+ * A row is not selectable under the `table` role, so it carries no
+ * `aria-selected`: the state is painted here and announced by the checkbox.
+ */
+declare class SlTableRow {
+    /** The row's key, required wherever selection or expansion is on. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The row's position in the whole set, one-based, written only where the
+     * table states a total: the practice warns that setting `aria-rowindex` on
+     * some rows and not others has devastating effects on assistive technology.
+     */
+    readonly rowIndex: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly table: SlTable;
+    readonly selected: _angular_core.Signal<boolean>;
+    readonly expanded: _angular_core.Signal<boolean>;
+    readonly detailId: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableRow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableRow, "tr[slTableRow]", ["slTableRow"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A column's name. `scope="col"` is what makes a screen reader repeat it for
+ * every cell under it, and `aria-sort` is written here and on no other header.
+ *
+ * A name cut by its own box — `text="truncate"` on a column with no room —
+ * reads `Op…` to the eye while the whole of it is still what a screen reader
+ * repeats under every cell. The hint closes that gap: it opens only while the
+ * name is measured as cut, which a header that wraps or fits never is, and it
+ * is shown rather than read — `describes="none"`, because the header already
+ * states the words.
+ */
+declare class SlTableColumnHeader {
+    /** The column's own key, which the sort descriptor names. */
+    readonly column: _angular_core.InputSignal<string | undefined>;
+    readonly scope: _angular_core.InputSignal<string | undefined>;
+    private readonly table;
+    private readonly tooltip;
+    private readonly native;
+    readonly ariaSort: _angular_core.Signal<_slotted_angular_table.TableSortDirection | null>;
+    /** The words the header itself holds, read when the hint is about to show them. */
+    protected readonly hint: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableColumnHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableColumnHeader, "th[slTableColumnHeader]", ["slTableColumnHeader"], { "column": { "alias": "column"; "required": false; "isSignal": true; }; "scope": { "alias": "scope"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof SlTableCellAxes; inputs: { "align": "align"; "blockAlign": "blockAlign"; "numeric": "numeric"; "text": "text"; "sticky": "sticky"; "stickyOffset": "stickyOffset"; }; outputs: {}; }, { directive: typeof i1.SlTooltip; inputs: {}; outputs: {}; }, { directive: typeof i1.SlTooltipTrigger; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * The cell that identifies the record, which a screen reader repeats in each of
+ * the cells beside it. It states no colour of its own, so a selected record's
+ * name turns with the row and a disabled one dims with it.
+ */
+declare class SlTableRowHeader {
+    readonly scope: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableRowHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableRowHeader, "th[slTableRowHeader]", ["slTableRowHeader"], { "scope": { "alias": "scope"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof SlTableCellAxes; inputs: { "align": "align"; "blockAlign": "blockAlign"; "numeric": "numeric"; "text": "text"; "sticky": "sticky"; "stickyOffset": "stickyOffset"; }; outputs: {}; }]>;
+}
+declare class SlTableCell {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableCell, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableCell, "td[slTableCell]", ["slTableCell"], {}, {}, never, never, true, [{ directive: typeof SlTableCellAxes; inputs: { "align": "align"; "blockAlign": "blockAlign"; "numeric": "numeric"; "text": "text"; "sticky": "sticky"; "stickyOffset": "stickyOffset"; }; outputs: {}; }]>;
+}
+/**
+ * The column's name wrapped in a button, which is what the APG's own sortable
+ * example does. The cycle is ascending, descending, then none.
+ *
+ * The consumer's own listener runs as well: this is a listener on the host, so
+ * both fire and a consumer who calls `preventDefault()` keeps the sort still.
+ */
+declare class SlTableSort {
+    /** Overrides the column the header states, where a header holds two. */
+    readonly column: _angular_core.InputSignal<string | undefined>;
+    private readonly table;
+    private readonly header;
+    press(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableSort, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableSort, "button[slTableSort]", ["slTableSort"], { "column": { "alias": "column"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * The slot beside a column's name for the controls it carries: a filter
+ * trigger, a column menu, a help hint. The family holds the place and the
+ * geometry; what a filter means is the consumer's query.
+ */
+declare class SlTableColumnActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableColumnActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableColumnActions, "span[slTableColumnActions]", ["slTableColumnActions"], {}, {}, never, never, true, never>;
+}
+/**
+ * A row's own checkbox, in the cell the family lays out. The control is
+ * `checkbox`'s: the cell is this family's and the chooser is not, which is the
+ * division `list-item` recorded. Its name is a visually hidden label rather
+ * than an `aria-label` on the wrapper, because the wrapper is not the control.
+ *
+ * `Shift` while pressing selects every row from the anchor to this one.
+ */
+declare class SlTableSelect {
+    /** The row this checkbox chooses. Read from the row when it is not stated. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly table: SlTable;
+    readonly row: SlTableRow;
+    readonly key: _angular_core.Signal<string | undefined>;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly name: _angular_core.Signal<string>;
+    press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableSelect, "td[slTableSelect]", ["slTableSelect"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof SlTableCellAxes; inputs: { "align": "align"; "blockAlign": "blockAlign"; "numeric": "numeric"; "text": "text"; "sticky": "sticky"; "stickyOffset": "stickyOffset"; }; outputs: {}; }]>;
+}
+/**
+ * The header's checkbox. It covers the rows in the DOM, is indeterminate while
+ * some of them are selected, and states the count it covers in its own name — a
+ * selection over a whole result set is a decision only the consumer's query can
+ * make.
+ */
+declare class SlTableSelectAll {
+    readonly table: SlTable;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly indeterminate: _angular_core.Signal<boolean>;
+    readonly name: _angular_core.Signal<string>;
+    press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableSelectAll, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableSelectAll, "th[slTableSelectAll]", ["slTableSelectAll"], {}, {}, never, never, true, [{ directive: typeof SlTableCellAxes; inputs: { "align": "align"; "blockAlign": "blockAlign"; "numeric": "numeric"; "text": "text"; "sticky": "sticky"; "stickyOffset": "stickyOffset"; }; outputs: {}; }]>;
+}
+/**
+ * The Disclosure pattern, borrowed whole: a `button` carrying `aria-expanded`
+ * and naming the row it opens.
+ */
+declare class SlTableExpander {
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly table: SlTable;
+    readonly row: SlTableRow;
+    readonly name: _angular_core.Signal<string>;
+    press(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableExpander, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableExpander, "button[slTableExpander]", ["slTableExpander"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * One row holding one cell that spans the table.
+ *
+ * **The consumer writes the `@if`.** Angular's own control flow is what keeps a
+ * closed detail out of the DOM entirely, and a component whose host is the `tr`
+ * cannot remove that `tr` from inside itself — an empty row is a row a screen
+ * reader still counts. React returns `null` from the component instead, and the
+ * two reach the same DOM; the asymmetry is the frameworks', not the family's.
+ */
+declare class SlTableDetail {
+    /** The row the detail belongs to. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** How many columns the detail spans. Defaults to the table's own count. */
+    readonly colSpan: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    private readonly table;
+    readonly span: _angular_core.Signal<number>;
+    readonly detailId: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableDetail, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableDetail, "tr[slTableDetail]", ["slTableDetail"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "colSpan": { "alias": "colSpan"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * What is shown when there is nothing. It takes a `result-state`, whose status
+ * axis already separates an empty set from a set a filter emptied.
+ */
+declare class SlTableEmpty {
+    readonly colSpan: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    private readonly table;
+    readonly span: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlTableEmpty, "td[slTableEmpty]", ["slTableEmpty"], { "colSpan": { "alias": "colSpan"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The skeleton rows of a first load: the table's shape before its content. A
+ * refresh over rows already read is the other state and is not this one —
+ * `loading` on the table dims the body and moves nothing.
+ */
+declare class SlTableLoader {
+    /** How many skeleton rows a first load draws. */
+    readonly skeletonRows: _angular_core.InputSignalWithTransform<number, unknown>;
+    private readonly table;
+    readonly skeleton: _angular_core.Signal<number[]>;
+    readonly cells: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlTableLoader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlTableLoader, "tbody[slTableLoader]", ["slTableLoader"], { "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Every part of the family, for a template that imports the set at once. */
+declare const SL_TABLE_PARTS: readonly [typeof SlTableBody, typeof SlTableCaption, typeof SlTableCell, typeof SlTableColumnActions, typeof SlTableColumnHeader, typeof SlTableDetail, typeof SlTableEmpty, typeof SlTableExpander, typeof SlTableFooter, typeof SlTableHead, typeof SlTableLoader, typeof SlTableRow, typeof SlTableRowHeader, typeof SlTableSelect, typeof SlTableSelectAll, typeof SlTableSort, typeof SlTableSummary];
+
+export { SL_TABLE_PARTS, SlTable, SlTableBody, SlTableBooleanFilter, SlTableCaption, SlTableCell, SlTableCellAxes, SlTableColumnActions, SlTableColumnHeader, SlTableContent, SlTableDateFilter, SlTableDateTimeFilter, SlTableDetail, SlTableEmpty, SlTableExpander, SlTableFilterBase, SlTableFilterShell, SlTableFooter, SlTableHead, SlTableIdFactory, SlTableLoader, SlTableNumberFilter, SlTableRow, SlTableRowHeader, SlTableSelect, SlTableSelectAll, SlTableSetFilter, SlTableSort, SlTableSummary, SlTableTextFilter, SlTableTimeFilter, TABLE_DEFAULTS, TABLE_ROW_SELECTOR, injectTableDefaults, provideTableDefaults };
+export type { TableAlign, TableDefaults, TableExpandedReason, TableFilterOperandContext, TableFilterOption, TableFilterReason, TableLayout, TableSelectionMode, TableSelectionReason, TableSortDescriptor, TableSortDirection, TableSortReason, TableSticky, TableText, TableVariant };
+//# sourceMappingURL=slotted-angular-table.d.ts.map