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

package/types/slotted-angular-data-grid.d.ts

@@ -0,0 +1,1077 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, DataGridMessages, FamilyTranslator } from '@slotted/core/i18n';
+import * as _slotted_core_grid from '@slotted/core/grid';
+import { GridColumnOverflow, GridColumn, GridColumnState, GridColumnStateChange, GridQuery, CsvOptions, GridNode, ResolvedGridColumn, GridQueryChange, GridColumnGroup, GridRange, GridCell, GridOutOfSpace, GridDensity, GridTree, SortDirection, GridViewOptions, GridViewStorage } from '@slotted/core/grid';
+export { GridViewStorage } from '@slotted/core/grid';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, Signal, WritableSignal, Injector } from '@angular/core';
+import { FilterKind, FilterDescriptor, FilterCondition, FilterJoin } from '@slotted/core/filter';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor } from '@angular/forms';
+import { SlMenu } from '@slotted/angular/menu';
+import { PlainDate, PlainTime, PlainDateTime } from '@slotted/core/date';
+
+type DataGridVariant = 'plain' | 'ruled' | 'framed';
+type DataGridStickyTo = 'scroll' | 'page';
+type DataGridSelectionMode = 'none' | 'single' | 'multiple' | 'range';
+type DataGridEditMode = 'cell' | 'row';
+type DataGridMode = 'client' | 'server';
+type DataGridVirtualize = 'auto' | boolean;
+type DataGridRowHeight = number | 'auto';
+/**
+ * What a frame too narrow for the template does: moves columns into the row's
+ * pop-in, scrolls, or — `auto` — pops in on a phone-wide or a touch frame
+ * narrower than a desktop and scrolls elsewhere.
+ */
+type DataGridColumnOverflow = GridColumnOverflow;
+type DataGridReason = 'pointer' | 'keyboard' | 'clear' | 'select' | 'programmatic';
+type DataGridExpandedGroups = readonly string[] | 'all';
+type DataGridSelection = string | readonly string[] | null;
+interface DataGridDataSourceResult<Row> {
+    readonly rows: readonly Row[];
+    /** The whole set's size, when known. */
+    readonly total?: number | undefined;
+    /** Whether a page past this one exists, when the total is not known. */
+    readonly hasMore?: boolean | undefined;
+}
+interface DataGridDataSource<Row> {
+    getRows(query: GridQuery, options: {
+        readonly signal: AbortSignal;
+    }): Promise<DataGridDataSourceResult<Row>>;
+    /** Answers kept, by query. Default 20; 0 keeps none. */
+    readonly cacheSize?: number | undefined;
+}
+interface DataGridPinnedRows {
+    readonly top?: readonly string[] | undefined;
+    readonly bottom?: readonly string[] | undefined;
+}
+interface DataGridRowsReorderEvent {
+    readonly key: string;
+    /** The row's index in `rows`. */
+    readonly from: number;
+    /** The index the row takes in `rows` once moved. */
+    readonly to: number;
+    readonly reason: 'pointer' | 'keyboard';
+    readonly event?: Event | undefined;
+}
+interface DataGridExportOptions extends Omit<CsvOptions, 'booleans'> {
+    /** What a boolean writes in the file. Default: the grid's own words, `filterYes` and `filterNo`. */
+    readonly booleans?: CsvOptions['booleans'] | undefined;
+    /** Default `export.csv`. */
+    readonly filename?: string | undefined;
+    /** `visible`: the rows the query left (every page in client mode; the received page in server mode). `selected`: the selected rows, in the grid's order. Default `visible`. */
+    readonly rows?: 'visible' | 'selected' | undefined;
+    /** `visible`: the columns not hidden, in the reader's order. `all`: every column the model declares. Default `visible`. */
+    readonly columns?: 'visible' | 'all' | undefined;
+}
+/** The request a query change carries: the value, plus which part of it moved. */
+interface DataGridQueryRequest extends ChangeRequest<GridQuery> {
+    readonly change: GridQueryChange;
+}
+interface DataGridColumnStateRequest extends ChangeRequest<GridColumnState> {
+    readonly change: GridColumnStateChange;
+}
+interface DataGridEditCommit<Row = unknown> {
+    readonly key: string;
+    readonly column: string;
+    readonly value: unknown;
+    readonly previous: unknown;
+    readonly row: Row;
+    readonly reason: 'keyboard' | 'pointer' | 'blur' | 'programmatic';
+    readonly changes: Readonly<Record<string, unknown>>;
+    /** A promise the consumer hands back keeps the cell pending until it settles. */
+    wait(promise: Promise<void>): void;
+}
+interface DataGridActivateEvent {
+    readonly key: string;
+    readonly reason: 'pointer' | 'keyboard';
+    readonly event: unknown;
+}
+/** What a projected cell template is handed. */
+interface DataGridCellContext<Row = unknown> {
+    readonly $implicit: Row;
+    readonly row: Row;
+    readonly key: string;
+    readonly column: GridColumn<Row>;
+    readonly value: unknown;
+    readonly text: string;
+    readonly current: boolean;
+    readonly selected: boolean;
+}
+interface DataGridEditorContext<Row = unknown> extends DataGridCellContext<Row> {
+    readonly draft: unknown;
+    readonly setDraft: (draft: unknown) => void;
+    readonly commit: () => void;
+    readonly cancel: () => void;
+    readonly invalid: boolean;
+    readonly message: string | null;
+}
+interface DataGridHeaderContext<Row = unknown> {
+    readonly $implicit: GridColumn<Row>;
+    readonly column: GridColumn<Row>;
+    readonly resolved: ResolvedGridColumn<Row>;
+    readonly sorted: 'ascending' | 'descending' | null;
+    readonly sortIndex: number | null;
+    readonly filtered: boolean;
+}
+interface DataGridGroupContext<Row = unknown> {
+    readonly $implicit: Extract<GridNode<Row>, {
+        kind: 'group';
+    }>;
+    readonly node: Extract<GridNode<Row>, {
+        kind: 'group';
+    }>;
+    readonly column: GridColumn<Row>;
+    readonly toggle: () => void;
+}
+interface DataGridFilterOperandContext {
+    readonly $implicit: unknown;
+    readonly column: string;
+    readonly operator: string;
+    readonly value: unknown;
+    readonly setValue: (value: unknown) => void;
+    readonly apply: () => void;
+    readonly label: string;
+}
+
+interface DataGridDefaults {
+    variant: DataGridVariant;
+    striped: boolean;
+    stickyHeader: boolean;
+    stickyTo: DataGridStickyTo;
+    selectionMode: DataGridSelectionMode;
+    editMode: DataGridEditMode;
+    filterRow: boolean;
+    virtualize: DataGridVirtualize;
+    rowHeight: DataGridRowHeight | undefined;
+    columnOverflow: DataGridColumnOverflow;
+    overscan: number;
+    pageSizes: readonly number[];
+    filterDebounce: number;
+    loadMoreThreshold: number;
+    skeletonRows: number;
+}
+declare const DATA_GRID_DEFAULTS: InjectionToken<DataGridDefaults>;
+/**
+ * An application decides once how its grids are framed, how they select and
+ * how they edit. A grid that states any of them itself still wins. Its words
+ * and its locale come from the language in force (`provideSlotted`).
+ */
+declare function provideDataGridDefaults(defaults: Partial<DataGridDefaults>): {
+    provide: InjectionToken<DataGridDefaults>;
+    useFactory: () => DataGridDefaults;
+};
+declare function injectDataGridDefaults(): DataGridDefaults;
+/** Application-scoped, so the server and the client produce the same sequence. */
+declare class SlDataGridIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * The surfaces a consumer replaces, each an `ng-template` the grid reads
+ * through `contentChildren` and renders only for the cells it mounts. A
+ * column-scoped template names the column; one with no name serves every
+ * column that has none of its own.
+ */
+declare class SlDataGridCellTemplate {
+    /** The column id, or empty for every column. */
+    readonly slDataGridCell: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridCellTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridCellTemplate, "ng-template[slDataGridCell]", never, { "slDataGridCell": { "alias": "slDataGridCell"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SlDataGridEditorTemplate {
+    readonly slDataGridEditor: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridEditorTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridEditorTemplate, "ng-template[slDataGridEditor]", never, { "slDataGridEditor": { "alias": "slDataGridEditor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SlDataGridHeaderTemplate {
+    readonly slDataGridHeader: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridHeaderTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridHeaderTemplate, "ng-template[slDataGridHeader]", never, { "slDataGridHeader": { "alias": "slDataGridHeader"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A column's help, opened from its column-help button in a popover under the
+ * column's `description`. Named by column: a help for every column is a
+ * description, and `GridColumn.description` already says that.
+ */
+declare class SlDataGridColumnHelp {
+    /** The column id. */
+    readonly slDataGridColumnHelp: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridColumnHelp, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridColumnHelp, "ng-template[slDataGridColumnHelp]", never, { "slDataGridColumnHelp": { "alias": "slDataGridColumnHelp"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SlDataGridFilterTemplate {
+    readonly slDataGridFilter: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridFilterTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridFilterTemplate, "ng-template[slDataGridFilter]", never, { "slDataGridFilter": { "alias": "slDataGridFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** A row's detail; its presence draws the expander column. */
+declare class SlDataGridDetailTemplate {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridDetailTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridDetailTemplate, "ng-template[slDataGridDetail]", never, {}, {}, never, never, true, never>;
+}
+declare class SlDataGridGroupTemplate {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridGroupTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridGroupTemplate, "ng-template[slDataGridGroup]", never, {}, {}, never, never, true, never>;
+}
+/** The empty, no-results or error state in place of the family's result-state. */
+declare class SlDataGridEmptyTemplate {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridEmptyTemplate, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridEmptyTemplate, "ng-template[slDataGridEmpty]", never, {}, {}, never, never, true, never>;
+}
+/** What stands in the bar under the grid: pagination, a count. */
+declare class SlDataGridFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDataGridFooter, "[slDataGridFooter]", never, {}, {}, never, never, true, never>;
+}
+
+declare const SELECTION_COLUMN = "__selection";
+declare const EXPANDER_COLUMN = "__expander";
+/** The reserved column that carries a row's drag handle. */
+declare const DRAG_COLUMN = "__drag";
+interface EditSession {
+    readonly cell: GridCell;
+    readonly columns: readonly string[];
+    readonly drafts: Readonly<Record<string, unknown>>;
+    readonly originals: Readonly<Record<string, unknown>>;
+    readonly status: 'editing' | 'pending' | 'invalid';
+    readonly messages: Readonly<Record<string, string>>;
+}
+type GroupNode = Extract<GridNode<unknown>, {
+    kind: 'group';
+}>;
+type RowNode = Extract<GridNode<unknown>, {
+    kind: 'row';
+}>;
+declare class SlDataGrid<Row = unknown> implements ControlValueAccessor {
+    protected readonly HEADER = "header";
+    protected readonly FILTER = "filter";
+    protected readonly SUMMARY = "summary";
+    protected readonly GROUP_PREFIX = "group:";
+    protected readonly SELECTION = "__selection";
+    protected readonly EXPANDER = "__expander";
+    protected readonly DRAG = "__drag";
+    protected readonly POPIN = "$popin";
+    /** The room between the header and the menu it opens: one space step. */
+    protected readonly MENU_OFFSET = 4;
+    /** The rows, or nothing when a `dataSource` answers for them. */
+    readonly rowsInput: _angular_core.InputSignal<readonly Row[] | undefined>;
+    /**
+     * The grid asks for its own rows: `getRows` is called with the query on
+     * every change, the request before it aborted, and the answer is kept by
+     * the query's text. The grid is in `server` mode, with the loading and the
+     * error states of its own; `reload()` drops the cache.
+     */
+    readonly dataSource: _angular_core.InputSignal<DataGridDataSource<Row> | undefined>;
+    readonly rowKey: _angular_core.InputSignal<keyof Row | ((row: Row) => string)>;
+    readonly columns: _angular_core.InputSignal<readonly GridColumn<Row>[]>;
+    readonly columnGroups: _angular_core.InputSignal<readonly GridColumnGroup[] | undefined>;
+    readonly mode: _angular_core.InputSignal<DataGridMode | undefined>;
+    readonly totalCountInput: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly hasMoreInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loadingInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly errorInput: _angular_core.InputSignal<string | null | undefined>;
+    private readonly sourced;
+    protected readonly rows: Signal<readonly Row[]>;
+    protected readonly totalCount: Signal<number | undefined>;
+    protected readonly hasMore: Signal<boolean | undefined>;
+    protected readonly loading: Signal<boolean>;
+    protected readonly error: Signal<string | null | undefined>;
+    readonly disabledKeys: _angular_core.InputSignal<readonly string[]>;
+    /**
+     * Marks a mounted cell whose value changed between two `rows`, for the
+     * stated milliseconds (`true` is 1200). A row that arrived is not a change.
+     */
+    readonly highlightChanges: _angular_core.InputSignal<number | boolean | undefined>;
+    readonly query: _angular_core.ModelSignal<GridQuery>;
+    readonly columnState: _angular_core.ModelSignal<Partial<GridColumnState> | undefined>;
+    readonly value: _angular_core.ModelSignal<DataGridSelection>;
+    readonly range: _angular_core.ModelSignal<GridRange | null>;
+    readonly current: _angular_core.ModelSignal<GridCell | null>;
+    readonly expanded: _angular_core.ModelSignal<readonly string[]>;
+    readonly expandedGroups: _angular_core.ModelSignal<DataGridExpandedGroups>;
+    readonly queryChangeRequest: _angular_core.OutputEmitterRef<DataGridQueryRequest>;
+    readonly columnStateChangeRequest: _angular_core.OutputEmitterRef<DataGridColumnStateRequest>;
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<DataGridSelection>>;
+    readonly rangeChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<GridRange | null>>;
+    readonly currentChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<GridCell | null>>;
+    readonly expandedChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    readonly expandedGroupsChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<DataGridExpandedGroups>>;
+    readonly editStart: _angular_core.OutputEmitterRef<GridCell>;
+    readonly editCommit: _angular_core.OutputEmitterRef<DataGridEditCommit<Row>>;
+    readonly editCancel: _angular_core.OutputEmitterRef<GridCell>;
+    readonly activate: _angular_core.OutputEmitterRef<DataGridActivateEvent>;
+    readonly loadMore: _angular_core.OutputEmitterRef<void>;
+    /** A branch `hasChildren` says has children opened and none are in `rows`. */
+    readonly loadChildren: _angular_core.OutputEmitterRef<{
+        key: string;
+        row: Row;
+    }>;
+    readonly rowsReorder: _angular_core.OutputEmitterRef<DataGridRowsReorderEvent>;
+    readonly retry: _angular_core.OutputEmitterRef<void>;
+    readonly manageColumns: _angular_core.OutputEmitterRef<void>;
+    /** The columns a narrow frame has taken out by their `priority`, each time either set changes. */
+    readonly outOfSpaceChange: _angular_core.OutputEmitterRef<GridOutOfSpace>;
+    readonly variant: _angular_core.InputSignal<DataGridVariant | undefined>;
+    /**
+     * The density of this grid alone, written as `data-slotted-density` on the
+     * root; absent or `null`, the grid takes the page's. The layers it opens
+     * are portals and stay at the page's density.
+     */
+    readonly density: _angular_core.InputSignal<GridDensity | null | undefined>;
+    readonly striped: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly stickyHeader: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly stickyTo: _angular_core.InputSignal<DataGridStickyTo | undefined>;
+    readonly selectionMode: _angular_core.InputSignal<DataGridSelectionMode | undefined>;
+    readonly editMode: _angular_core.InputSignal<DataGridEditMode | undefined>;
+    readonly filterRow: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly virtualize: _angular_core.InputSignal<DataGridVirtualize | undefined>;
+    readonly rowHeight: _angular_core.InputSignal<DataGridRowHeight | undefined>;
+    /**
+     * What a frame too narrow for the template does. `popin` moves the columns
+     * of least `priority` into a pop-in at the foot of each row, as labelled
+     * values; `scroll` keeps every column and scrolls sideways; `auto`, the
+     * default, pops in on a frame under 600px, or under 1024px when the main
+     * pointer is coarse, and scrolls elsewhere.
+     */
+    readonly columnOverflow: _angular_core.InputSignal<_slotted_core_grid.GridColumnOverflow | undefined>;
+    readonly overscan: _angular_core.InputSignal<number | undefined>;
+    readonly filterDebounce: _angular_core.InputSignal<number | undefined>;
+    readonly loadMoreThreshold: _angular_core.InputSignal<number | undefined>;
+    readonly skeletonRows: _angular_core.InputSignal<number | undefined>;
+    readonly activatable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the column menu offers Manage columns. The grid has no manager of
+     * its own — `column-manager` edits `columnState` — so the item is drawn only
+     * for an application that answers `manageColumns`, the way React draws it
+     * only when `onManageColumns` is given.
+     */
+    readonly manageable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly expandable: _angular_core.InputSignal<boolean | ((row: Row) => boolean) | undefined>;
+    /**
+     * Rows as a tree: each row names its parent by key. The open branches are
+     * `expanded`; `query.group` is ignored. The root is a `treegrid`.
+     */
+    readonly tree: _angular_core.InputSignal<GridTree<Row> | undefined>;
+    /**
+     * A handle per row, dragged with the pointer or moved with Alt and the
+     * vertical arrows. The grid keeps no order of its own: `rowsReorder` says
+     * where the row goes in `rows` and the consumer moves it. Only while the
+     * query is at rest — no sort, filter, search or group — and without a
+     * tree; elsewhere the handle is disabled.
+     */
+    readonly rowsReorderable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Rows held at the top or the bottom of the body, by key, in the stated
+     * order: out of the query — never sorted, filtered or paged — and always on
+     * screen, under the head and over the summary.
+     */
+    readonly pinnedRows: _angular_core.InputSignal<DataGridPinnedRows | undefined>;
+    readonly height: _angular_core.InputSignal<string | number | undefined>;
+    /** The id of the element that names the grid; a static `aria-label` names it directly. */
+    readonly labelledBy: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * grid's name (`grid`), every control, state and announcement.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<DataGridMessages> | undefined>;
+    /** The locale cells, numbers and dates are written in. Default: the language in force. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly timeZone: _angular_core.InputSignal<string | undefined>;
+    readonly showRange: _angular_core.InputSignal<boolean | undefined>;
+    private readonly cellTemplates;
+    private readonly editorTemplates;
+    private readonly headerTemplates;
+    private readonly filterTemplates;
+    private readonly helpTemplates;
+    protected readonly detailTemplate: Signal<SlDataGridDetailTemplate | undefined>;
+    protected readonly groupTemplate: Signal<SlDataGridGroupTemplate | undefined>;
+    protected readonly emptyTemplate: Signal<SlDataGridEmptyTemplate | undefined>;
+    private readonly footerContent;
+    private readonly scrollRef;
+    private readonly columnMenus;
+    private readonly defaults;
+    private readonly host;
+    private readonly injector;
+    readonly id: string;
+    /** The family's words in the language in force, with this grid's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<DataGridMessages>;
+    /** What a drag of a column or a row says, in the language in force. */
+    private readonly dragT;
+    private readonly providedLocale;
+    private readonly ownLabel;
+    protected readonly resolvedVariant: Signal<DataGridVariant>;
+    protected readonly resolvedStriped: Signal<boolean>;
+    protected readonly resolvedStickyHeader: Signal<boolean>;
+    protected readonly resolvedStickyTo: Signal<DataGridStickyTo>;
+    protected readonly resolvedSelectionMode: Signal<DataGridSelectionMode>;
+    protected readonly resolvedEditMode: Signal<DataGridEditMode>;
+    protected readonly resolvedFilterRow: Signal<boolean>;
+    protected readonly resolvedVirtualize: Signal<DataGridVirtualize>;
+    protected readonly resolvedRowHeight: Signal<DataGridRowHeight | undefined>;
+    protected readonly resolvedColumnOverflow: Signal<_slotted_core_grid.GridColumnOverflow>;
+    protected readonly resolvedOverscan: Signal<number>;
+    protected readonly resolvedDebounce: Signal<number>;
+    protected readonly resolvedThreshold: Signal<number>;
+    protected readonly resolvedSkeleton: Signal<number>;
+    protected readonly resolvedLocale: Signal<string>;
+    protected readonly resolvedMode: Signal<DataGridMode>;
+    protected readonly ariaLabel: Signal<string | null>;
+    protected readonly blockSize: Signal<string | null>;
+    protected readonly rowBlockSize: Signal<string | null>;
+    protected readonly autoRows: Signal<boolean>;
+    private readonly formatOptions;
+    rowKeyOf(row: Row): string;
+    textOf(column: GridColumn<Row>, row: Row): string;
+    private readonly disabledSet;
+    isDisabled(key: string): boolean;
+    isEditable(column: GridColumn<Row>, row: Row): boolean;
+    private readonly anyEditable;
+    isExpandable(row: Row): boolean;
+    private readonly effectiveState;
+    /** The gutters' width, before the first data column; where a pop-in's fields start. */
+    protected readonly leading: Signal<number>;
+    /** Every column the reader has not hidden, before the frame's width is asked. */
+    private readonly layout;
+    /** The scroller's inner width; 0 until it is measured, and nothing is taken out before. */
+    private readonly frameWidth;
+    /** Whether the main pointer is coarse — a finger. A render without `matchMedia` reads a fine one. */
+    private readonly coarsePointer;
+    /** The policy the frame's width and the pointer settle `auto` to. */
+    private readonly effectiveColumnOverflow;
+    /**
+     * The columns a frame too narrow for the template has taken out, by their
+     * `priority`: those drawn in each row's pop-in, and those that declined it
+     * with `popin: false`. Read from the frame's width, which neither set
+     * changes, so the measure never loops. Never in `columnState`. Empty while
+     * `columnOverflow` settles to `scroll`.
+     *
+     * The width is read first: an unmeasured frame takes nothing out and reads
+     * no input, so a template that reads the set before the grid's inputs are
+     * bound — a column manager written before the grid — gets an empty set.
+     */
+    readonly outOfSpace: Signal<GridOutOfSpace>;
+    protected readonly resolved: Signal<ResolvedGridColumn<Row>[]>;
+    /** The columns drawn in each row's pop-in, in the order of the resolved columns. */
+    protected readonly popinColumns: Signal<ResolvedGridColumn<Row>[]>;
+    protected readonly hasPopin: Signal<boolean>;
+    private readonly resolvedById;
+    protected readonly hasSelectionColumn: Signal<boolean>;
+    protected readonly hasExpanderColumn: Signal<boolean>;
+    protected readonly rowSelectable: Signal<boolean>;
+    protected readonly hasDragColumn: Signal<boolean>;
+    private readonly gutters;
+    protected readonly gutterIds: Signal<string[]>;
+    protected readonly columnIds: Signal<string[]>;
+    protected readonly gutterCount: Signal<number>;
+    /** The pop-in is one more column for a reader, after every visible one, with no track. */
+    protected readonly ariaColCount: Signal<number>;
+    protected readonly popinIndex: Signal<number>;
+    /** The columns the cursor walks: the visible ones, then the pop-in's. */
+    private readonly cursorColumns;
+    protected readonly expanderIndex: Signal<number>;
+    protected readonly dragIndex: Signal<number>;
+    protected readonly template: Signal<string>;
+    protected readonly hasGroups: Signal<boolean>;
+    protected readonly headerRowCount: Signal<number>;
+    protected indexOf(columnId: string): number;
+    protected filterKind(column: ResolvedGridColumn<Row>): FilterKind | null;
+    protected readonly pinned: Signal<{
+        top: RowNode[];
+        bottom: RowNode[];
+        keys: ReadonlySet<string> | null;
+    }>;
+    private readonly bodyRows;
+    protected readonly pinnedTopEntries: Signal<{
+        node: {
+            readonly kind: "row";
+            readonly key: string;
+            readonly row: unknown;
+            readonly index: number;
+            readonly groups: readonly string[];
+            readonly level: number;
+            readonly parent: string | null;
+            readonly childCount: number;
+            readonly open: boolean;
+        };
+        index: number;
+        rowIndex: number;
+    }[]>;
+    protected readonly pinnedBottomEntries: Signal<{
+        node: {
+            readonly kind: "row";
+            readonly key: string;
+            readonly row: unknown;
+            readonly index: number;
+            readonly groups: readonly string[];
+            readonly level: number;
+            readonly parent: string | null;
+            readonly childCount: number;
+            readonly open: boolean;
+        };
+        index: number;
+        rowIndex: number;
+    }[]>;
+    protected readonly applied: Signal<{
+        total: number | null;
+        nodes: readonly GridNode<Row>[];
+        rows: readonly Row[];
+        hasMore: boolean;
+        aggregates: Readonly<Record<string, unknown>>;
+    }>;
+    protected readonly nodes: Signal<readonly GridNode<Row>[]>;
+    protected readonly total: Signal<number | null>;
+    protected readonly aggregated: Signal<ResolvedGridColumn<Row>[]>;
+    /** The aggregating columns in the pop-in: the summary row draws their totals in its own. */
+    protected readonly popinAggregated: Signal<ResolvedGridColumn<Row>[]>;
+    protected readonly hasSummary: Signal<boolean>;
+    protected readonly firstAggregateIndex: Signal<number>;
+    protected readonly status: Signal<"rows" | "empty" | "error" | "loading" | "no-results">;
+    protected readonly resultStatus: Signal<"empty" | "error" | "no-results">;
+    protected readonly emptyTitle: Signal<string>;
+    protected readonly ariaRowCount: Signal<number>;
+    protected readonly summaryRowIndex: Signal<number>;
+    protected readonly skeletonRowsList: Signal<number[]>;
+    protected skeletonWidth(index: number): string;
+    private readonly cursorRows;
+    private readonly bodyStart;
+    private readonly bodyEnd;
+    private readonly scrollTop;
+    private readonly scrollLeft;
+    private readonly viewport;
+    private readonly measuredRow;
+    private readonly rowSizes;
+    /** The body row's height: stated, or measured from the rows drawn, or the default. */
+    protected readonly rowSize: Signal<number>;
+    protected readonly windowsRows: Signal<boolean>;
+    private readonly metrics;
+    protected readonly rowWindow: Signal<{
+        startIndex: number;
+        endIndex: number;
+        startOffset: number;
+        totalSize: number;
+    }>;
+    private readonly heldRows;
+    protected readonly mountedEntries: Signal<{
+        node: GridNode<Row>;
+        index: number;
+        rowIndex: number;
+    }[]>;
+    private readonly middle;
+    private readonly windowsColumns;
+    protected readonly mountedColumns: Signal<ResolvedGridColumn<Row>[]>;
+    private readonly selectableKeys;
+    private readonly selectedList;
+    private readonly selectedSet;
+    private anchor;
+    isSelected(key: string): boolean;
+    private readonly selectableSet;
+    protected readonly selectedCount: Signal<number>;
+    protected readonly allState: Signal<"none" | "all" | "some">;
+    protected readonly selectAllName: Signal<string>;
+    private touched;
+    private notify;
+    private readonly formDisabled;
+    private requestValue;
+    private commitSelection;
+    toggleSelected(key: string, options: {
+        range?: boolean;
+        source?: unknown;
+        reason?: DataGridReason;
+    }): void;
+    protected shiftHeld(source: unknown): boolean;
+    toggleAll(source?: unknown): void;
+    selectAll(): void;
+    clearSelection(): void;
+    private readonly cursorGrid;
+    private readonly bounds;
+    private readonly rangeDragging;
+    private rangeAnchor;
+    private requestRange;
+    private beginRange;
+    private extendRange;
+    private readonly focused;
+    private pendingFocus;
+    private lastRowIndex;
+    isCurrent(row: string, column: string): boolean;
+    protected isTabStop(row: string, column: string): boolean;
+    /**
+     * Whether a row draws a pop-in: a record's row, held or not, and the
+     * summary while a column in the pop-in has a total to show there.
+     */
+    protected hasPopinCell(row: string): boolean;
+    /** The pop-in's column on a row that draws none is that row's last visible column. */
+    private landOn;
+    private requestCurrent;
+    private focusCellNow;
+    setCurrent(cell: GridCell, reason: DataGridReason, source?: unknown): void;
+    private flushFocus;
+    focusCell(cell: GridCell): void;
+    protected readonly filterOpen: _angular_core.WritableSignal<string | null>;
+    protected readonly resizing: _angular_core.WritableSignal<string | null>;
+    sortOf(columnId: string): {
+        direction: SortDirection;
+        index: number;
+    } | null;
+    protected ariaSort(columnId: string): SortDirection | null;
+    protected isSortedAlone(columnId: string, direction: SortDirection): boolean;
+    filterOf(columnId: string): FilterDescriptor | null;
+    private requestQuery;
+    private labelOf;
+    private announceSort;
+    pressSort(columnId: string, append: boolean, source?: unknown, reason?: DataGridReason): void;
+    setSort(columnId: string, direction: SortDirection | null, source?: unknown): void;
+    setFilter(columnId: string, filter: FilterDescriptor | null, reason: DataGridReason, source?: unknown): void;
+    protected applyPanel(columnId: string, event: {
+        filter: FilterDescriptor | null;
+        reason: 'pointer' | 'keyboard' | 'clear';
+        said: string;
+    }): void;
+    protected onFilterOpenChange(columnId: string, open: boolean): void;
+    protected toggleFilterPanel(columnId: string): void;
+    protected clearFilters(source?: unknown): void;
+    private countsCache;
+    countsFor(columnId: string): ReadonlyMap<string, number>;
+    private requestState;
+    pin(columnId: string, zone: 'start' | 'end' | null, source?: unknown): void;
+    /** Hides a column and announces it; the undo is the application's, from the request's `previous`. */
+    hide(columnId: string, source?: unknown, reason?: DataGridReason): void;
+    resizeTo(columnId: string, width: number, reason: DataGridReason, source?: unknown): void;
+    resizeBy(columnId: string, delta: number, source?: unknown): void;
+    private measureFit;
+    /** One column to its content; without an id, every resizable column at once, as one request. */
+    autofit(columnId?: string, source?: unknown): void;
+    /** The fit behind the resizer, the menu, the keyboard and `autofit()`, each with its own reason. */
+    protected fit(columnId: string | null, reason: DataGridReason, source?: unknown): void;
+    moveColumn(columnId: string, direction: -1 | 1, source?: unknown): void;
+    private resizeSession;
+    protected beginResize(event: PointerEvent, column: ResolvedGridColumn<Row>): void;
+    protected moveResize(event: PointerEvent, column: ResolvedGridColumn<Row>): void;
+    protected endResize(event: PointerEvent): void;
+    protected readonly dragState: _angular_core.WritableSignal<{
+        dragging: string | null;
+        target: string | null;
+        offset: number | null;
+        /** Where the scroller stood at the last move: the line follows the viewport, not the content. */
+        scrollTop: number;
+    }>;
+    private drag;
+    private readonly draggables;
+    private readonly draggableNodes;
+    private readonly expandedSet;
+    protected readonly treeColumn: Signal<string | null>;
+    private readonly nodeByKey;
+    private readonly loadingChildren;
+    protected isLoadingChildren(key: string): boolean;
+    /** In a tree, `expanded` is the branch; the detail is a leaf's alone. */
+    protected detailOpen(node: RowNode): boolean;
+    protected treeKind(node: RowNode, column: string): 'branch' | 'leaf' | null;
+    toggleBranch(key: string, source?: unknown, reason?: DataGridReason): void;
+    isExpanded(key: string): boolean;
+    toggleExpanded(key: string, source?: unknown, reason?: DataGridReason): void;
+    toggleGroup(key: string, source?: unknown, reason?: DataGridReason): void;
+    protected detailId(key: string): string;
+    protected groupCount(node: GroupNode): string;
+    protected groupContext(node: GroupNode): DataGridGroupContext<Row>;
+    protected aggregateText(column: ResolvedGridColumn<Row>, value: unknown): string;
+    readonly edit: _angular_core.WritableSignal<EditSession | null>;
+    private rowOf;
+    startEdit(cell: GridCell, seed?: string | null): void;
+    setDraft(columnId: string, draft: unknown): void;
+    cancelEdit(): void;
+    private nextEditableCell;
+    commitEdit(reason: 'keyboard' | 'pointer' | 'blur' | 'programmatic', options?: {
+        move?: 'down' | 'next' | 'previous' | 'stay';
+    }): void;
+    stopEdit(options?: {
+        commit?: boolean;
+    }): void;
+    protected cellState(node: RowNode, column: ResolvedGridColumn<Row>): {
+        value: unknown;
+        text: string;
+        current: boolean;
+        selected: boolean;
+        editing: boolean;
+        invalid: boolean;
+        message: string | null;
+        pending: boolean;
+        inRange: boolean;
+        edges: _slotted_core_grid.RangeEdge[];
+        readonly: boolean;
+        changed: "a" | "b" | null;
+        tree: "branch" | "leaf" | null;
+    };
+    protected cellContext(node: RowNode, column: ResolvedGridColumn<Row>, cell: ReturnType<SlDataGrid<Row>['cellState']>): DataGridCellContext<Row>;
+    protected editorContext(node: RowNode, column: ResolvedGridColumn<Row>, cell: ReturnType<SlDataGrid<Row>['cellState']>): DataGridEditorContext<Row>;
+    protected headerContext(column: ResolvedGridColumn<Row>): DataGridHeaderContext<Row>;
+    private templateFor;
+    protected cellTemplate(columnId: string): never;
+    protected editorTemplate(columnId: string): never;
+    protected headerTemplate(columnId: string): never;
+    protected helpTemplate(columnId: string): never;
+    protected hasHelp(column: ResolvedGridColumn<Row>): boolean;
+    protected helpLabel(column: ResolvedGridColumn<Row>): string;
+    protected descriptionId(columnId: string): string;
+    protected filterTemplate(columnId: string): never;
+    protected readonly hasFooterContent: Signal<boolean>;
+    protected readonly showsFooter: Signal<boolean>;
+    protected readonly rangeText: Signal<string | null>;
+    protected readonly groupCells: Signal<{
+        key: string;
+        first: number;
+        span: number;
+        label: string;
+        pinned: "start" | "end" | null;
+        pinOffset: number;
+    }[]>;
+    private readonly changedFor;
+    protected readonly changedDuration: Signal<string | null>;
+    private readonly changedCells;
+    private changedGeneration;
+    private readonly changedVersion;
+    private changedTimer;
+    private previousRows;
+    private changedOf;
+    private markChanges;
+    private sweepChanges;
+    constructor();
+    private wireDrag;
+    private readonly sourceCache;
+    private sourceController;
+    private readonly sourceAttempt;
+    /** The same query again, after a failure; with a source, else `retry` is emitted. */
+    protected onRetry(): void;
+    /** Drops the data source's cache and asks the query again. */
+    reload(): void;
+    private fetchFromSource;
+    protected readonly rowsReorderableNow: Signal<boolean>;
+    protected readonly rowDragState: _angular_core.WritableSignal<{
+        dragging: string | null;
+        offset: number | null;
+        scrollLeft: number;
+    }>;
+    private rowDrag;
+    private measureEdges;
+    private readonly rowDraggables;
+    private readonly rowDraggableNodes;
+    protected rowHandleLabel(key: string): string;
+    /** What a row is called: its row header's text, else its key. */
+    private rowLabelOf;
+    private mountedRowKeys;
+    /** Where a row lands in `rows` when dropped before the visible item at `index`. */
+    private rowMove;
+    private moveRow;
+    private wireRowDrag;
+    private attachRowDraggables;
+    private attachDraggables;
+    announce(message: string): void;
+    private rtl;
+    protected onCellFocus(cell: GridCell, event: FocusEvent): void;
+    protected onRootFocusOut(event: FocusEvent): void;
+    protected onRootKeyDown(event: KeyboardEvent): void;
+    private swallowClick;
+    /** The pointer of the last press on a cell: `touch` and `pen` activate on one press. */
+    private pressedWith;
+    private touchActivatedAt;
+    private keyboardMenuAt;
+    private columnMenuFor;
+    /**
+     * Opens a column's menu against an anchor other than its button: the point
+     * a context menu was opened at, or the header cell. Focus returns to the
+     * header cell, which is where the reader was.
+     */
+    private openColumnMenu;
+    /** The button opens the menu where it always did: under itself, focus returning to it. */
+    protected anchorToButton(menu: SlMenu): void;
+    /**
+     * A secondary press on a data column's header opens its menu at the press.
+     * The browser keeps its own menu under Shift, and over a field, where cut,
+     * copy and paste are the reader's; a `contextmenu` just after Shift+F10 or
+     * the Menu key opened the menu from the keyboard is that key's echo.
+     */
+    protected onHeaderContextMenu(event: MouseEvent, columnId: string): void;
+    protected onHeaderClick(event: MouseEvent, column: ResolvedGridColumn<Row>): void;
+    protected onBodyCellClick(event: MouseEvent, cell: GridCell): void;
+    protected onCellDoubleClick(event: MouseEvent, cell: GridCell): void;
+    protected onCellPointerDown(event: PointerEvent, cell: GridCell): void;
+    protected onCellPointerEnter(event: PointerEvent, cell: GridCell): void;
+    private copyRange;
+    protected onCellKeyDown(event: KeyboardEvent, cell: GridCell): void;
+    scrollToRow(key: string, align?: 'start' | 'center' | 'end' | 'nearest'): void;
+    scrollToColumn(columnId: string): void;
+    scrollToCell(cell: GridCell): void;
+    getVisibleRows(): readonly Row[];
+    /** The file's text, by `toCsv`, for the consumer who sends it elsewhere. */
+    toCsv(options?: DataGridExportOptions): string;
+    /**
+     * Builds the file and hands it to the browser as a download: an anchor is
+     * the one way a browser saves a file without a permission prompt, and the
+     * URL is revoked as soon as the click has taken it.
+     */
+    exportCsv(options?: DataGridExportOptions): void;
+    writeValue(value: DataGridSelection | undefined): void;
+    registerOnChange(fn: (value: DataGridSelection) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGrid<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDataGrid<any>, "sl-data-grid", ["slDataGrid"], { "rowsInput": { "alias": "rows"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "columnGroups": { "alias": "columnGroups"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "totalCountInput": { "alias": "totalCount"; "required": false; "isSignal": true; }; "hasMoreInput": { "alias": "hasMore"; "required": false; "isSignal": true; }; "loadingInput": { "alias": "loading"; "required": false; "isSignal": true; }; "errorInput": { "alias": "error"; "required": false; "isSignal": true; }; "disabledKeys": { "alias": "disabledKeys"; "required": false; "isSignal": true; }; "highlightChanges": { "alias": "highlightChanges"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "columnState": { "alias": "columnState"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "expandedGroups": { "alias": "expandedGroups"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "stickyTo": { "alias": "stickyTo"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "editMode": { "alias": "editMode"; "required": false; "isSignal": true; }; "filterRow": { "alias": "filterRow"; "required": false; "isSignal": true; }; "virtualize": { "alias": "virtualize"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "columnOverflow": { "alias": "columnOverflow"; "required": false; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; "filterDebounce": { "alias": "filterDebounce"; "required": false; "isSignal": true; }; "loadMoreThreshold": { "alias": "loadMoreThreshold"; "required": false; "isSignal": true; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; "activatable": { "alias": "activatable"; "required": false; "isSignal": true; }; "manageable": { "alias": "manageable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "tree": { "alias": "tree"; "required": false; "isSignal": true; }; "rowsReorderable": { "alias": "rowsReorderable"; "required": false; "isSignal": true; }; "pinnedRows": { "alias": "pinnedRows"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "labelledBy": { "alias": "labelledBy"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "timeZone": { "alias": "timeZone"; "required": false; "isSignal": true; }; "showRange": { "alias": "showRange"; "required": false; "isSignal": true; }; }, { "query": "queryChange"; "columnState": "columnStateChange"; "value": "valueChange"; "range": "rangeChange"; "current": "currentChange"; "expanded": "expandedChange"; "expandedGroups": "expandedGroupsChange"; "queryChangeRequest": "queryChangeRequest"; "columnStateChangeRequest": "columnStateChangeRequest"; "valueChangeRequest": "valueChangeRequest"; "rangeChangeRequest": "rangeChangeRequest"; "currentChangeRequest": "currentChangeRequest"; "expandedChangeRequest": "expandedChangeRequest"; "expandedGroupsChangeRequest": "expandedGroupsChangeRequest"; "editStart": "editStart"; "editCommit": "editCommit"; "editCancel": "editCancel"; "activate": "activate"; "loadMore": "loadMore"; "loadChildren": "loadChildren"; "rowsReorder": "rowsReorder"; "retry": "retry"; "manageColumns": "manageColumns"; "outOfSpaceChange": "outOfSpaceChange"; }, ["cellTemplates", "editorTemplates", "headerTemplates", "filterTemplates", "helpTemplates", "detailTemplate", "groupTemplate", "emptyTemplate", "footerContent"], ["[slDataGridFooter]"], true, never>;
+}
+
+interface PersistedGridViewOptions<Row> extends GridViewOptions {
+    /** The entry the view is kept under. */
+    readonly key: string;
+    /** The model, so a column it no longer has is dropped on read. */
+    readonly columns: readonly GridColumn<Row>[];
+    /** Default `window.localStorage`; `null` keeps the view in memory only. */
+    readonly storage?: GridViewStorage | null | undefined;
+    /** What the view is before anything was saved, and after `reset`. */
+    readonly defaultQuery?: GridQuery | undefined;
+    readonly defaultColumnState?: Partial<GridColumnState> | undefined;
+    /** The density before anything was saved, and after `reset`. Default `null`: the page's. */
+    readonly defaultDensity?: GridDensity | null | undefined;
+    /** Required outside an injection context. */
+    readonly injector?: Injector | undefined;
+}
+interface PersistedGridView {
+    /** Bind with `[(query)]`. */
+    readonly query: WritableSignal<GridQuery>;
+    /** Bind with `[(columnState)]`. */
+    readonly columnState: WritableSignal<GridColumnState>;
+    /** Bind with `[density]`; `null` inherits the page's density. */
+    readonly density: WritableSignal<GridDensity | null>;
+    /** Back to the defaults, and the entry removed. */
+    reset(): void;
+}
+/**
+ * The reader's view of a grid, kept across visits: the column state, the
+ * query and the density, read once from the store and written after every change. Three
+ * writable signals for the grid's bindings. The store is reached
+ * inside `try` both ways — a private window that refuses, a quota that is
+ * full and a server that has no window all leave the view in memory.
+ */
+declare function persistedGridView<Row>({ key, columns, storage, defaultQuery, defaultColumnState, defaultDensity, injector, ...options }: PersistedGridViewOptions<Row>): PersistedGridView;
+
+type Condition = FilterCondition<string, unknown>;
+declare function filterKindOf(kind: string): FilterKind | null;
+/**
+ * The control an operand of a kind is edited in: one family per kind, all at
+ * `sm`; `plain` in the filter row and `outline` in the panel. A date, a time
+ * and a date-time are pickers — the field with the control that opens the
+ * calendar or the list beside it — because a reader who does not type dates
+ * still has to filter by one.
+ */
+declare class SlDataGridOperand {
+    readonly kind: _angular_core.InputSignal<FilterKind>;
+    readonly column: _angular_core.InputSignal<GridColumn<unknown>>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly label: _angular_core.InputSignal<string>;
+    /** The grid's words, in the language in force. */
+    readonly t: _angular_core.InputSignal<FamilyTranslator<DataGridMessages>>;
+    readonly variant: _angular_core.InputSignal<"plain" | "outline">;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly counts: _angular_core.InputSignal<ReadonlyMap<string, number> | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<unknown>;
+    readonly applyRequest: _angular_core.OutputEmitterRef<void>;
+    protected readonly numberValue: _angular_core.Signal<number | null>;
+    protected readonly textValue: _angular_core.Signal<string>;
+    protected readonly dateValue: _angular_core.Signal<PlainDate | null>;
+    protected readonly timeValue: _angular_core.Signal<PlainTime | null>;
+    protected readonly dateTimeValue: _angular_core.Signal<PlainDateTime | null>;
+    protected readonly truths: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly setOptions: _angular_core.Signal<_slotted_core_grid.GridColumnOption[]>;
+    protected readonly setItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly setValue: _angular_core.Signal<readonly string[]>;
+    protected countOf(value: string): string;
+    protected asList(value: unknown): any[];
+    protected isoDay(value: unknown): string | null;
+    protected isoTime(value: unknown): string | null;
+    protected isoDateTime(value: unknown): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridOperand, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDataGridOperand, "sl-data-grid-operand", never, { "kind": { "alias": "kind"; "required": true; "isSignal": true; }; "column": { "alias": "column"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "t": { "alias": "t"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "counts": { "alias": "counts"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "applyRequest": "applyRequest"; }, never, never, true, never>;
+}
+/** Whether the operator's two operands are edited in one control. */
+declare function isRangeOperand(kind: FilterKind, operator: string): boolean;
+/**
+ * A `between` on a date, a time or a date-time is one range picker: one
+ * frame that says the run while it is drawn, takes the ends in either order
+ * and fits a column's width, where two fields side by side broke into two
+ * lines at the widths a filter row has. The rule `table` took in its second
+ * reopening. The descriptor is unchanged: two ISO operands.
+ */
+declare class SlDataGridRangeOperand {
+    readonly kind: _angular_core.InputSignal<FilterKind>;
+    readonly start: _angular_core.InputSignal<unknown>;
+    readonly end: _angular_core.InputSignal<unknown>;
+    /** The grid's words, in the language in force. */
+    readonly t: _angular_core.InputSignal<FamilyTranslator<DataGridMessages>>;
+    readonly variant: _angular_core.InputSignal<"plain" | "outline">;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly rangeChange: _angular_core.OutputEmitterRef<{
+        start: string | null;
+        end: string | null;
+    }>;
+    protected readonly dateRange: _angular_core.Signal<{
+        start: PlainDate | null;
+        end: PlainDate | null;
+    }>;
+    protected readonly timeRange: _angular_core.Signal<{
+        start: PlainTime | null;
+        end: PlainTime | null;
+    }>;
+    protected readonly dateTimeRange: _angular_core.Signal<{
+        start: PlainDateTime | null;
+        end: PlainDateTime | null;
+    }>;
+    protected isoDay(value: unknown): string | null;
+    protected isoTime(value: unknown): string | null;
+    protected isoDateTime(value: unknown): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridRangeOperand, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDataGridRangeOperand, "sl-data-grid-range-operand", never, { "kind": { "alias": "kind"; "required": true; "isSignal": true; }; "start": { "alias": "start"; "required": false; "isSignal": true; }; "end": { "alias": "end"; "required": false; "isSignal": true; }; "t": { "alias": "t"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; }, { "rangeChange": "rangeChange"; }, never, never, true, never>;
+}
+/**
+ * The compact panel: one line per condition, the join as two words on the
+ * second, Clear and Apply at the end. It edits a draft; nothing reaches the
+ * grid until Apply.
+ */
+declare class SlDataGridFilterPanel {
+    readonly column: _angular_core.InputSignal<ResolvedGridColumn<unknown>>;
+    readonly kind: _angular_core.InputSignal<FilterKind>;
+    readonly committed: _angular_core.InputSignal<FilterDescriptor | null>;
+    /** The grid's words, in the language in force. */
+    readonly t: _angular_core.InputSignal<FamilyTranslator<DataGridMessages>>;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly counts: _angular_core.InputSignal<ReadonlyMap<string, number> | undefined>;
+    readonly customTemplate: _angular_core.InputSignal<TemplateRef<DataGridFilterOperandContext> | null>;
+    /** The normalised descriptor, or null, with how it was applied. */
+    readonly applyRequest: _angular_core.OutputEmitterRef<{
+        filter: FilterDescriptor | null;
+        reason: "pointer" | "keyboard" | "clear";
+        said: string;
+    }>;
+    /** Written by the effect below before the first read: the inputs are not set at construction. */
+    readonly draft: _angular_core.WritableSignal<FilterDescriptor>;
+    constructor();
+    private blank;
+    protected readonly operators: _angular_core.Signal<readonly string[]>;
+    protected readonly operatorItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly lines: _angular_core.Signal<readonly (0 | 1)[]>;
+    protected readonly clearable: _angular_core.Signal<boolean>;
+    protected conditionAt(index: number): Condition;
+    protected operandsOf(index: number): 0 | 1 | 2;
+    protected slotsOf(index: number): readonly (0 | 1)[];
+    protected operandOf(index: number, slot: 0 | 1): {} | null;
+    protected operandLabel(index: number, slot: 0 | 1): string;
+    protected operatorName(operator: string): string;
+    protected joinName(join: FilterJoin): string;
+    protected context(index: number, slot: 0 | 1): DataGridFilterOperandContext;
+    protected setJoin(join: string): void;
+    protected setOperator(index: number, operator: string): void;
+    protected setOperand(index: number, slot: 0 | 1, operand: unknown): void;
+    protected setOperands(index: number, start: unknown, end: unknown): void;
+    protected rangeAt(index: number): boolean;
+    protected apply(reason: 'pointer' | 'keyboard'): void;
+    protected clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridFilterPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDataGridFilterPanel, "sl-data-grid-filter-panel", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "kind": { "alias": "kind"; "required": true; "isSignal": true; }; "committed": { "alias": "committed"; "required": false; "isSignal": true; }; "t": { "alias": "t"; "required": true; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "counts": { "alias": "counts"; "required": false; "isSignal": true; }; "customTemplate": { "alias": "customTemplate"; "required": false; "isSignal": true; }; }, { "applyRequest": "applyRequest"; }, never, never, true, never>;
+}
+/**
+ * The operand of the filter row: the kind's control, `plain`, filling the
+ * cell, with the operator as a symbol button at its start. Text and number
+ * apply after the debounce and on Enter; the others on change.
+ */
+declare class SlDataGridFilterRowOperand {
+    readonly column: _angular_core.InputSignal<ResolvedGridColumn<unknown>>;
+    readonly kind: _angular_core.InputSignal<FilterKind>;
+    readonly committed: _angular_core.InputSignal<FilterDescriptor | null>;
+    /** The grid's words, in the language in force. */
+    readonly t: _angular_core.InputSignal<FamilyTranslator<DataGridMessages>>;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly counts: _angular_core.InputSignal<ReadonlyMap<string, number> | undefined>;
+    readonly debounce: _angular_core.InputSignal<number>;
+    readonly customTemplate: _angular_core.InputSignal<TemplateRef<DataGridFilterOperandContext> | null>;
+    readonly filterChange: _angular_core.OutputEmitterRef<{
+        filter: FilterDescriptor | null;
+        reason: "pointer" | "keyboard";
+    }>;
+    readonly operator: _angular_core.WritableSignal<string>;
+    readonly draft: _angular_core.WritableSignal<{
+        value: unknown;
+        end: unknown;
+    }>;
+    private timer;
+    private seen;
+    constructor();
+    protected readonly operators: _angular_core.Signal<readonly string[]>;
+    protected readonly operands: _angular_core.Signal<0 | 1 | 2>;
+    protected readonly slots: _angular_core.Signal<readonly (0 | 1)[]>;
+    protected readonly symbol: _angular_core.Signal<string>;
+    protected readonly range: _angular_core.Signal<boolean>;
+    protected operatorName(operator: string): string;
+    protected rowPlaceholder(slot: 0 | 1): string;
+    protected operandLabel(slot: 0 | 1): string;
+    protected context(slot: 0 | 1): DataGridFilterOperandContext;
+    private commit;
+    protected write(slot: 0 | 1, next: unknown, immediate?: boolean): void;
+    protected writeBoth(start: unknown, end: unknown): void;
+    protected applyNow(): void;
+    protected chooseOperator(next: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridFilterRowOperand, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDataGridFilterRowOperand, "sl-data-grid-filter-row-operand", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "kind": { "alias": "kind"; "required": true; "isSignal": true; }; "committed": { "alias": "committed"; "required": false; "isSignal": true; }; "t": { "alias": "t"; "required": true; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "counts": { "alias": "counts"; "required": false; "isSignal": true; }; "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; "customTemplate": { "alias": "customTemplate"; "required": false; "isSignal": true; }; }, { "filterChange": "filterChange"; }, never, never, true, never>;
+}
+/**
+ * The editor a kind implies: the field family of that kind, `plain` and `sm`,
+ * filling the cell. The draft is the domain value.
+ */
+declare class SlDataGridEditor {
+    readonly column: _angular_core.InputSignal<GridColumn<unknown>>;
+    readonly draft: _angular_core.InputSignal<unknown>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly message: _angular_core.InputSignal<string | null>;
+    /** The grid's words, in the language in force. */
+    readonly t: _angular_core.InputSignal<FamilyTranslator<DataGridMessages>>;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly draftChange: _angular_core.OutputEmitterRef<unknown>;
+    protected readonly kind: _angular_core.Signal<_slotted_core_grid.GridColumnKind>;
+    protected readonly multiple: _angular_core.Signal<boolean>;
+    protected readonly numberValue: _angular_core.Signal<number | null>;
+    protected readonly textValue: _angular_core.Signal<string>;
+    protected readonly dateValue: _angular_core.Signal<PlainDate | null>;
+    protected readonly timeValue: _angular_core.Signal<PlainTime | null>;
+    protected readonly dateTimeValue: _angular_core.Signal<PlainDateTime | null>;
+    protected readonly setItems: _angular_core.Signal<{
+        label: string;
+        value: string;
+    }[]>;
+    protected readonly setValue: _angular_core.Signal<string | readonly string[] | null>;
+    protected isoDay(value: unknown): string | null;
+    protected isoTime(value: unknown): string | null;
+    protected isoDateTime(value: unknown): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDataGridEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDataGridEditor, "sl-data-grid-editor", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "draft": { "alias": "draft"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "t": { "alias": "t"; "required": true; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; }, { "draftChange": "draftChange"; }, never, never, true, never>;
+}
+
+export { DATA_GRID_DEFAULTS, DRAG_COLUMN, EXPANDER_COLUMN, SELECTION_COLUMN, SlDataGrid, SlDataGridCellTemplate, SlDataGridColumnHelp, SlDataGridDetailTemplate, SlDataGridEditor, SlDataGridEditorTemplate, SlDataGridEmptyTemplate, SlDataGridFilterPanel, SlDataGridFilterRowOperand, SlDataGridFilterTemplate, SlDataGridFooter, SlDataGridGroupTemplate, SlDataGridHeaderTemplate, SlDataGridIdFactory, SlDataGridOperand, SlDataGridRangeOperand, filterKindOf, injectDataGridDefaults, isRangeOperand, persistedGridView, provideDataGridDefaults };
+export type { DataGridActivateEvent, DataGridCellContext, DataGridColumnOverflow, DataGridColumnStateRequest, DataGridDataSource, DataGridDataSourceResult, DataGridDefaults, DataGridEditCommit, DataGridEditMode, DataGridEditorContext, DataGridExpandedGroups, DataGridExportOptions, DataGridFilterOperandContext, DataGridGroupContext, DataGridHeaderContext, DataGridMode, DataGridPinnedRows, DataGridQueryRequest, DataGridReason, DataGridRowHeight, DataGridRowsReorderEvent, DataGridSelection, DataGridSelectionMode, DataGridStickyTo, DataGridVariant, DataGridVirtualize, PersistedGridView, PersistedGridViewOptions };
+//# sourceMappingURL=slotted-angular-data-grid.d.ts.map