@lilydesignsystem/angular-data-grid 0.0.0-stage → 0.10.0

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

@@ -0,0 +1,1056 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+type ExportFormat = "csv" | "tsv" | "xlsx";
+/**
+ * A live formula and the result it last computed. In an .xlsx the cell keeps the formula with the result cached
+ * (a spreadsheet user keeps the live formula); CSV and TSV carry only the result.
+ */
+type ExportFormula = {
+  formula: string;
+  result: unknown;
+};
+/** Whether a cell value is an {@link ExportFormula}. */
+export declare function isExportFormula(value: unknown): value is ExportFormula;
+/** A header row and rows of cell values. A cell is a string, number, boolean, `Date`, an {@link ExportFormula}, or empty. */
+type ExportTable = {
+  headers: string[];
+  rows: unknown[][];
+};
+type DelimitedOptions = {
+  /** Field separator. Default `","` (use `"\t"` for TSV). */
+  delimiter?: string;
+  /** Write the header row. Default true. */
+  header?: boolean;
+  /** Prefix a UTF-8 byte-order mark so Excel opens the file as UTF-8. Default false. */
+  bom?: boolean;
+  /** Defuse spreadsheet formulas: a string starting with `=`, `+`, `-`, `@`, tab or CR gets a leading `'`. Default true. */
+  safe?: boolean;
+  /** Line ending. Default `"\r\n"` (RFC 4180). */
+  eol?: string;
+};
+type XlsxOptions = {
+  /** Worksheet name (31 characters at most; `[]:*?/\` are replaced). Default `"Sheet1"`. */
+  sheetName?: string;
+  /** Write the header row, in bold. Default true. */
+  header?: boolean;
+};
+export declare const MIME_TYPES: Record<ExportFormat, string>;
+/** One cell as text. Numbers and booleans are never treated as formulas; only strings are defused. */
+export declare function cellText(value: unknown, safe?: boolean): string;
+/** CSV/TSV text for a table. Fields containing the delimiter, a quote or a line break are quoted. */
+export declare function toDelimited(table: ExportTable, options?: DelimitedOptions): string;
+export declare function toCsv(table: ExportTable, options?: Omit<DelimitedOptions, "delimiter">): string;
+export declare function toTsv(table: ExportTable, options?: Omit<DelimitedOptions, "delimiter">): string;
+/** Column index (0-based) to a spreadsheet column name: 0 → A, 25 → Z, 26 → AA. */
+export declare function columnName(index: number): string;
+/** An .xlsx workbook with one worksheet, as bytes. */
+export declare function toXlsx(table: ExportTable, options?: XlsxOptions): Uint8Array;
+export declare function crc32(bytes: Uint8Array): number;
+/** A ZIP archive holding `entries` uncompressed. */
+export declare function zipStore(entries: {
+  name: string;
+  data: Uint8Array;
+}[]): Uint8Array;
+/** The file for `table` in `format`, as a `Blob`. CSV and TSV carry a UTF-8 byte-order mark so Excel reads them as UTF-8. */
+export declare function exportBlob(table: ExportTable, format: ExportFormat, options?: {
+  sheetName?: string;
+  header?: boolean;
+}): Blob;
+/** A filename with the format's extension, without doubling one the name already has. */
+export declare function exportFilename(base: string, format: ExportFormat): string;
+/** Saves a blob through a temporary link. Does nothing outside a browser. */
+export declare function downloadBlob(blob: Blob, filename: string): void;
+/** The table as tab-separated text with its header row, ready to paste into a spreadsheet (no byte-order mark, formula text defused). */
+export declare function toClipboardText(table: ExportTable): string;
+/**
+ * Write `text` to the clipboard: the async Clipboard API where there is one, otherwise a hidden, selected `<textarea>` and
+ * `document.execCommand("copy")`. Resolves true when something was copied, false when neither path worked (no permission, no
+ * secure context, no DOM). Never throws.
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+type DataGridCellType = "text" | "number" | "link" | "date" | "time" | "time-zone" | "select" | "radio" | "person" | "file" | "rollup" | "formula";
+/** A time of day and the zone it is stated in (an IANA zone id, or a bare offset such as `+01:00`). */
+type DataGridZonedTime = {
+  time: string;
+  timeZone: string;
+};
+/** One person: the name is always shown as text; the avatar is the consumer's. */
+type DataGridPerson = {
+  id: string;
+  name?: string;
+  email?: string;
+  avatarUrl?: string;
+};
+/** One file's metadata. The bytes live elsewhere; the grid never uploads. */
+type DataGridFile = {
+  id: string;
+  name: string;
+  size?: number;
+  type?: string;
+  href?: string;
+};
+/** What a rollup reduces its related values with. */
+type DataGridAggregate = "count" | "countUnique" | "sum" | "avg" | "median" | "min" | "max" | "range" | "percentTrue" | "percentEmpty";
+/** What a formula engine hands back: a value, or an error message shown as text. */
+type DataGridFormulaResult = {
+  value: unknown;
+} | {
+  error: string;
+};
+/** What a formula engine is given. `rows` is every row, for references to other rows. */
+type DataGridFormulaContext = {
+  row: Record<string, unknown>;
+  rows: Record<string, unknown>[];
+  columnId: string;
+};
+/** An option of a `select` or `radio` column. The label is displayed; the id is stored. */
+type DataGridOption = {
+  id: string;
+  label: string;
+  disabled?: boolean;
+  group?: string;
+  [key: string]: unknown;
+};
+/** A link value: an address, or an address with a label. */
+type DataGridLink = {
+  href: string;
+  label?: string;
+  external?: boolean;
+};
+/** The column facets a type can fill in. Structural so this module does not import the grid. */
+type TypedColumn = {
+  id: string;
+  type?: DataGridCellType;
+  locale?: string;
+  options?: DataGridOption[];
+  sortBy?: "label" | "order";
+  exportAs?: "label" | "id" | "email";
+  numberFormat?: Intl.NumberFormatOptions;
+  dateFormat?: Intl.DateTimeFormatOptions;
+  timeFormat?: Intl.DateTimeFormatOptions;
+  accessor?: (row: Record<string, unknown>) => unknown;
+  format?: (value: unknown, row: Record<string, unknown>) => string;
+  compare?: (a: unknown, b: unknown) => number;
+  filterText?: (value: unknown, row: Record<string, unknown>) => string;
+  exportValue?: (row: Record<string, unknown>) => unknown;
+  align?: "start" | "center" | "end";
+  editor?: string;
+  parse?: (draft: string, row: Record<string, unknown>) => unknown;
+  editable?: boolean;
+  /** `time-zone`: the zones the editor offers, as `{ id, label }`. */
+  timeZones?: DataGridOption[];
+  /** `time-zone`: the date (ISO) used to order zoned times and to name a zone. Never computed here. */
+  referenceDate?: string;
+  /** `rollup`: how the related values are reduced. */
+  aggregate?: DataGridAggregate;
+  /** `rollup`: anything the named aggregates do not cover. */
+  reduce?: (values: unknown[], row: Record<string, unknown>) => unknown;
+  /** `rollup`: reads the related values. Defaults to the row's own array at the column id. */
+  relation?: (row: Record<string, unknown>) => unknown[];
+  /** `rollup` and `formula`: the type of the result, so it formats and sorts like one. */
+  resultType?: "number" | "date" | "text";
+  /** `formula`: evaluates an expression. Lily ships no engine and never evaluates a string itself. */
+  evaluate?: (expression: string, context: DataGridFormulaContext) => DataGridFormulaResult;
+  /** `person`: how many people show before "+N". */
+  maxPeople?: number;
+  /** `file`: formats a size in bytes for display. */
+  formatSize?: (bytes: number) => string;
+  /** Set by `resolveColumn` for a `formula`: the expression the row holds (the editor shows this, not the result). */
+  source?: (row: Record<string, unknown>) => unknown;
+  /** Set by `resolveColumn` for a `formula`: the error message for a row, or undefined. */
+  errorOf?: (row: Record<string, unknown>) => string | undefined;
+};
+/** An address safe to put in an `href`: http(s), mailto, tel, or a relative one. Anything else (`javascript:`, `data:`) is null. */
+export declare function safeHref(href: unknown): string | null;
+/** A link value as `{ href, label?, external? }`; a plain string is the address. */
+export declare function linkParts(value: unknown): DataGridLink | null;
+export declare function linkLabel(value: unknown): string;
+/** A civil date `YYYY-MM-DD` that exists on the calendar. */
+export declare function isCivilDate(text: unknown): text is string;
+/** A civil time `HH:mm` or `HH:mm:ss`, 24-hour. */
+export declare function isCivilTime(text: unknown): text is string;
+/** A civil date as a `Date` at UTC midnight, or null. Typed, so an export writes a real spreadsheet date. */
+export declare function civilDateToDate(text: unknown): Date | null;
+/** An IANA zone id the platform knows, or a bare offset such as `+01:00`. */
+export declare function isValidTimeZone(timeZone: unknown): timeZone is string;
+/** A zoned time: `{ time: "HH:mm[:ss]", timeZone }` with a real time and a known zone. */
+export declare function isZonedTime(value: unknown): value is DataGridZonedTime;
+/**
+ * A zoned time as a number for ordering. With a `referenceDate` (ISO, supplied by the consumer: never computed here)
+ * it is the UTC minute of that instant, so equal instants compare equal; without one it is the stated local time and
+ * the zone is ignored.
+ */
+export declare function zonedMinutes(value: unknown, referenceDate?: string): number | null;
+/** A zoned time as the UTC time of day (`HH:mm`) at a reference date. Null without a valid reference date or value. */
+export declare function zonedUtcTime(value: unknown, referenceDate?: string): string | null;
+/** The people in a value: one object or an array, each with an id. */
+export declare function peopleOf(value: unknown): DataGridPerson[];
+/** A person's text: the name, or the id when there is none (never blank). */
+export declare const personName: (person: DataGridPerson) => string;
+/** The files in a value: an array of `{ id, name, … }`. */
+export declare function filesOf(value: unknown): DataGridFile[];
+/** Reduces related values to one result. An empty set is empty (null), not 0, except `count`. */
+export declare function aggregateValues(kind: DataGridAggregate, values: unknown[]): unknown;
+/** Whether a (parsed) value is unacceptable for the column's type; the grid refuses the edit. Empty is always acceptable. */
+export declare function isInvalidForType(column: TypedColumn, value: unknown): boolean;
+/**
+ * The column with its type's defaults filled in under its own props. A column with no `type` is returned as is.
+ * `rows` is every row: a `formula` hands it to the consumer's engine for references to other rows. A rollup's and a
+ * formula's results are computed once per row each time the columns are resolved (`rows` or `columns` changed),
+ * never per comparison or keystroke.
+ */
+export declare function resolveColumn<T extends TypedColumn>(column: T, gridLocale?: string, rows?: Record<string, unknown>[]): T;
+type DataGridSortDirection = "ascending" | "descending" | "none";
+type DataGridSort = {
+  columnId: string;
+  direction: DataGridSortDirection;
+};
+type DataGridSelectionMode = "none" | "single" | "multiple";
+type DataGridRow = Record<string, unknown>;
+/** What `exportHandler` and the `exportFile` output receive, before the file is saved. */
+type DataGridExport = {
+  format: ExportFormat;
+  /** The file name, with its extension. */
+  filename: string;
+  /** How many data rows (the header is not counted). */
+  rowCount: number;
+  /** The file. */
+  blob: Blob;
+};
+/** What a column's `cell` template receives (as `$implicit`). */
+type DataGridCellContext = {
+  value: unknown;
+  formatted: string;
+  row: DataGridRow;
+  column: DataGridColumn;
+};
+/** What the `cellEdit` output carries after a cell edit is committed. */
+type DataGridCellEdit = {
+  rowId: string;
+  row: DataGridRow;
+  columnId: string;
+  /** The parsed new value (a number for the `"number"` editor, the text otherwise). */
+  value: unknown;
+  /** The cell's value before the edit. */
+  previous: unknown;
+};
+/** What a person editor template receives (as `$implicit`). */
+type DataGridPersonEditorContext = {
+  value: unknown;
+  commit: (value: unknown) => void;
+  cancel: () => void;
+};
+type DataGridColumn = {
+  /** Stable column identifier; also the default property read from each row. */
+  id: string;
+  /** Accessible + visible column header text. */
+  header: string;
+  /** Reads this column's raw value from a row. Defaults to `row[id]`. */
+  accessor?: (row: DataGridRow) => unknown;
+  /** Formats a raw value for display. Defaults to `String(value)` (`""` for null/undefined). */
+  format?: (value: unknown, row: DataGridRow) => string;
+  /** Column participates in sorting. */
+  sortable?: boolean;
+  /** Orders two raw values when sorting. `null`/`undefined` always sort last, before `compare` is called. */
+  compare?: (a: unknown, b: unknown) => number;
+  /** Column participates in the text filter. Default true. */
+  filterable?: boolean;
+  /** Column can be resized (pointer + keyboard). */
+  resizable?: boolean;
+  /** Column can be reordered: Alt+ArrowLeft/Right on its focused header, or dragging the header onto another. */
+  movable?: boolean;
+  /** Pins the column: its header and cells get `data-pinned="start"` / `"end"` for the consumer's sticky CSS. */
+  pinned?: "start" | "end";
+  /** Set `false` to leave the column out of an export. Default true. */
+  exportable?: boolean;
+  /** The value this column exports for a row. */
+  exportValue?: (row: DataGridRow) => unknown;
+  /** Column can be hidden via the column-visibility control. */
+  hidable?: boolean;
+  /** Initial pixel width, meaningful only when `resizable`. */
+  width?: number;
+  /** Custom cell content: a template receiving the cell context as `$implicit`. */
+  cell?: TemplateRef<{
+    $implicit: DataGridCellContext;
+  }>;
+  /** The header's content in place of the `header` text. `header` stays the accessible name. */
+  headerCell?: TemplateRef<{
+    $implicit: DataGridColumn;
+  }>;
+  /** Cells can be edited in place: F2 or Enter on a focused cell, a double click, or the button `labels.editCell` gates. */
+  editable?: boolean;
+  /** The editor's control. Default `"text"`; a `type` sets its own. */
+  editor?: "text" | "number" | "link" | "date" | "time" | "time-zone" | "select" | "radio" | "person" | "formula";
+  /** The kind of value in this column: a bundle of defaults for `format`, `compare`, `filterText`, `exportValue`, `align` and `editor`. */
+  type?: DataGridCellType;
+  /** BCP 47 locale for this column's formatting and collation. */
+  /** Shown instead of nothing when this column's value is missing (`null`, `undefined` or `""`). Overrides the grid's `emptyValue`. A missing value always carries `data-empty` on its cell. */
+  emptyValue?: string;
+  locale?: string;
+  /** `select` and `radio`: the choices. */
+  options?: DataGridOption[];
+  /** `time-zone`: the zones the editor's select offers. */
+  timeZones?: DataGridOption[];
+  /** `time-zone`: the date (ISO) that orders zoned times and names a zone. Never computed by the grid. */
+  referenceDate?: string;
+  /** `time-zone`: an export adds a second column holding the UTC time of day at `referenceDate`. */
+  exportUtc?: boolean;
+  /** `rollup`: how the related values are reduced. */
+  aggregate?: "count" | "countUnique" | "sum" | "avg" | "median" | "min" | "max" | "range" | "percentTrue" | "percentEmpty";
+  /** `rollup`: a reduction the named aggregates do not cover. */
+  reduce?: (values: unknown[], row: DataGridRow) => unknown;
+  /** `rollup`: reads the related values. */
+  relation?: (row: DataGridRow) => unknown[];
+  /** `rollup` and `formula`: the result's type. */
+  resultType?: "number" | "date" | "text";
+  /** `formula`: evaluates an expression. Lily ships no engine and never evaluates a string itself. */
+  evaluate?: (expression: string, context: {
+    row: DataGridRow;
+    rows: DataGridRow[];
+    columnId: string;
+  }) => {
+    value: unknown;
+  } | {
+    error: string;
+  };
+  /** `person`: how many people show before "+N". */
+  maxPeople?: number;
+  /** `person`: an avatar beside the name. Decorative. */
+  avatar?: TemplateRef<{
+    $implicit: DataGridPerson;
+  }>;
+  /** `person`: the editor template (`$implicit`: `{ value, commit, cancel }`). Without it a person cell is read-only. */
+  personEditor?: TemplateRef<{
+    $implicit: DataGridPersonEditorContext;
+  }>;
+  /** `file`: formats a size in bytes. */
+  formatSize?: (bytes: number) => string;
+  /** `file`: the `accept` of the file input. */
+  accept?: string;
+  /** `file`: whether the input takes several files. Default true. */
+  multiple?: boolean;
+  /** `select`: sort by option label (default) or by option order. */
+  sortBy?: "label" | "order";
+  /** `select`/`radio`: export the option's `"label"` or `"id"`. `person`: `"email"`. */
+  exportAs?: "label" | "id" | "email";
+  /** `number`: options for `Intl.NumberFormat`. */
+  numberFormat?: Intl.NumberFormatOptions;
+  /** `date`: options for `Intl.DateTimeFormat`. */
+  dateFormat?: Intl.DateTimeFormatOptions;
+  /** `time`: options for `Intl.DateTimeFormat`. */
+  timeFormat?: Intl.DateTimeFormatOptions;
+  /** The text the grid's filter matches for a value. */
+  filterText?: (value: unknown, row: DataGridRow) => string;
+  /** Turns the editor's text into the committed value. */
+  parse?: (draft: string, row: DataGridRow) => unknown;
+  /** Refuses a value: return a message and the cell stays in edit mode with `aria-invalid`. */
+  validate?: (value: unknown, row: DataGridRow) => string | undefined;
+  /** Set for a `formula` column: reads the expression a row holds. */
+  source?: (row: DataGridRow) => unknown;
+  /** Set for a `formula` column: the error message for a row, if any. */
+  errorOf?: (row: DataGridRow) => string | undefined;
+  /** Body cells of this column are `<th scope="row" role="rowheader">`. */
+  rowHeader?: boolean;
+  /** Horizontal alignment of the column's cells. */
+  align?: "start" | "center" | "end";
+  /** Extra class on each body cell of this column. */
+  cellClass?: string | ((ctx: DataGridCellContext) => string);
+  /** Extra attributes on each body cell of this column. */
+  cellAttrs?: (ctx: DataGridCellContext) => Record<string, string>;
+};
+/**
+ * Every field is optional, but its presence gates the control it names — no baked-in English fallback.
+ * See the Svelte canonical's spec/index.md §5.
+ */
+type DataGridLabels = {
+  search?: string;
+  /** Accessible name of the select that limits the search to one column. Gates the select (needs `searchAllFields` too). */
+  searchField?: string;
+  /** The select's first option: search every column. */
+  searchAllFields?: string;
+  /** Accessible name of the pager. When given, the pager is a labelled `<nav>` landmark (the headless `PaginationNav`); without it the pager is a plain `<div>`. */
+  pagination?: string;
+  /** Visible text of the copy button, which puts the export (header row first, tab-separated) on the clipboard for pasting into a spreadsheet. Gates the button. */
+  copy?: string;
+  /** Announced after a copy: (how many rows). */
+  copyAnnouncement?: (rowCount: number) => string;
+  /** Announced when the clipboard could not be written. */
+  copyFailed?: string;
+  /** Announced after Ctrl/Cmd+Z puts an earlier value back: (column header, the restored text). */
+  undoAnnouncement?: (header: string, text: string) => string;
+  /** Announced after Ctrl/Cmd+Shift+Z (or Ctrl+Y) re-applies an edit: (column header, the text). */
+  redoAnnouncement?: (header: string, text: string) => string;
+  columnVisibility?: string;
+  columnVisibilityOption?: (header: string) => string;
+  resizeHandle?: (header: string) => string;
+  selectAll?: string;
+  selectionColumn?: string;
+  selectRow?: (rowLabel: string) => string;
+  previousPage?: string;
+  nextPage?: string;
+  pageStatus?: (page: number, pageCount: number, rowCount: number) => string;
+  pageAnnouncement?: (page: number, pageCount: number) => string;
+  sortAnnouncement?: (header: string, direction: DataGridSortDirection) => string;
+  filterAnnouncement?: (matchCount: number, totalCount: number) => string;
+  selectionAnnouncement?: (selectedCount: number) => string;
+  columnMoveAnnouncement?: (header: string, position: number, count: number) => string;
+  editCell?: (header: string, rowLabel: string) => string;
+  cellEditor?: (header: string) => string;
+  editAnnouncement?: (header: string, value: string) => string;
+  export?: string;
+  exportCsv?: string;
+  exportTsv?: string;
+  exportExcel?: string;
+  exportAnnouncement?: (format: ExportFormat, rowCount: number, filename: string) => string;
+  invalidValue?: (header: string, type: string) => string;
+  opensInNewTab?: (text: string) => string;
+  radioGroup?: (header: string, rowLabel: string) => string;
+  timeZone?: (header: string) => string;
+  exportUtcHeader?: (header: string) => string;
+  morePeople?: (count: number) => string;
+  removeFile?: (name: string) => string;
+  fileInput?: (header: string, rowLabel: string) => string;
+  formulaEditor?: (header: string) => string;
+  rollupDescription?: (header: string) => string;
+  editCancelAnnouncement?: (header: string) => string;
+  editError?: (header: string, message: string) => string;
+};
+/** What a footer template receives (as `$implicit`). */
+type DataGridFooterContext = {
+  columns: DataGridColumn[];
+  rows: DataGridRow[];
+};
+type DataGridEntry = {
+  row: DataGridRow;
+  id: string;
+};
+type Editing = {
+  rowId: string;
+  columnId: string;
+  draft: string;
+  zone?: string;
+  error?: string;
+  invalid?: boolean;
+};
+type RenderItem = {
+  kind: "row";
+  index: number;
+} | {
+  kind: "spacer";
+  rows: number;
+  key: string;
+};
+/** Stable per-instance id prefix; SSR-safe (no Math.random / Date.now). */
+export declare function nextDataGridId(): string;
+/** Sets a record of attributes on its host element (Angular cannot spread a dictionary in a template). */
+export declare class DataGridAttrs {
+  readonly lilyDataGridAttrs: import("@angular/core/types/core").InputSignal<Record<string, string> | undefined>;
+  private readonly host;
+  private applied;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<DataGridAttrs, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<DataGridAttrs, "[lilyDataGridAttrs]", never, {
+    "lilyDataGridAttrs": {
+      "alias": "lilyDataGridAttrs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class DataGrid {
+  /** Accessible name for the grid, passed through to DataTable. */
+  readonly label: import("@angular/core/types/core").InputSignal<string>;
+  /** Optional visible caption. */
+  readonly caption: import("@angular/core/types/core").InputSignal<string | undefined>;
+  /** Column definitions. */
+  readonly columns: import("@angular/core/types/core").InputSignal<DataGridColumn[]>;
+  /** Row data. */
+  readonly rows: import("@angular/core/types/core").InputSignal<DataGridRow[]>;
+  /** BCP 47 locale for the typed columns' formatting and collation. Never defaulted: with none, values show as stored. */
+  readonly locale: import("@angular/core/types/core").InputSignal<string | undefined>;
+  /** What a cell shows when its value is missing (`null`, `undefined` or `""`), for example `"—"`. A column's own `emptyValue` wins. No default: Lily ships no text. The cell always carries `data-empty`, and an export is unaffected. */
+  readonly emptyValue: import("@angular/core/types/core").InputSignal<string | undefined>;
+  /** In development, log (once per grid) the labels the grid's features call for but `labels` leaves out. Default `true`; it never logs in production. */
+  readonly warnMissingLabels: import("@angular/core/types/core").InputSignal<boolean>;
+  /** Where missing values sort: `"last"` (default, in both directions) or `"first"`. */
+  readonly nulls: import("@angular/core/types/core").InputSignal<"first" | "last">;
+  /** Make every column movable (Alt+Arrow on its header, or drag it) unless its own `movable` is `false`. Default `false`. */
+  readonly movableColumns: import("@angular/core/types/core").InputSignal<boolean>;
+  /** Hides rows for which it returns false (a status or date-range filter). Combines with the text filter; both must pass. */
+  readonly rowFilter: import("@angular/core/types/core").InputSignal<((row: DataGridRow) => boolean) | undefined>;
+  /** Derives a stable id per row. Defaults to the row's index in `rows`. */
+  readonly rowId: import("@angular/core/types/core").InputSignal<(row: DataGridRow, index: number) => string>;
+  /** Row selection mode. */
+  readonly selectionMode: import("@angular/core/types/core").InputSignal<DataGridSelectionMode>;
+  /** Rows per page. Unset disables pagination. */
+  readonly pageSize: import("@angular/core/types/core").InputSignal<number | undefined>;
+  /** If set, persist column widths / hidden columns / sort to localStorage. */
+  readonly storageKey: import("@angular/core/types/core").InputSignal<string | undefined>;
+  /** User-facing strings. */
+  readonly labels: import("@angular/core/types/core").InputSignal<DataGridLabels>;
+  /** `"grid"` (default): roving-tabindex grid. `"table"`: a plain table with ordinary tab stops. */
+  readonly mode: import("@angular/core/types/core").InputSignal<"table" | "grid">;
+  /** Extra class on each body row. */
+  readonly rowClass: import("@angular/core/types/core").InputSignal<((row: DataGridRow) => string) | undefined>;
+  /** Extra attributes on each body row. */
+  readonly rowAttrs: import("@angular/core/types/core").InputSignal<((row: DataGridRow) => Record<string, string>) | undefined>;
+  /** Enter on a body cell with no widget, and a click outside any widget, emit `rowActivate` — only when this is true (Angular outputs cannot be tested for a listener). */
+  readonly activateRows: import("@angular/core/types/core").InputSignal<boolean>;
+  /** Shown in one row spanning every column when no row is to be shown. */
+  readonly empty: import("@angular/core/types/core").InputSignal<TemplateRef<void> | undefined>;
+  /** Rendered inside a `<tfoot>`: a template receiving `{ columns, rows }` as `$implicit`. */
+  readonly footer: import("@angular/core/types/core").InputSignal<TemplateRef<{
+    $implicit: DataGridFooterContext;
+  }> | undefined>;
+  /** Sets `aria-busy` on the table. */
+  readonly busy: import("@angular/core/types/core").InputSignal<boolean>;
+  /** Wrap the table in a scrollable `data-grid-scroll` region. Default true. */
+  readonly scroll: import("@angular/core/types/core").InputSignal<boolean>;
+  /** The file name without its extension. Default `"data-grid"`. */
+  readonly exportFilename: import("@angular/core/types/core").InputSignal<string>;
+  /** What an export holds: `"view"` (default) or `"selected"`. */
+  readonly exportScope: import("@angular/core/types/core").InputSignal<"view" | "selected">;
+  /** `.xlsx` only: a `formula` column keeps the live expression with the result cached. */
+  readonly exportFormulas: import("@angular/core/types/core").InputSignal<boolean>;
+  /** Called with the file before it is saved. Return `false` to keep the grid from saving it. */
+  readonly exportHandler: import("@angular/core/types/core").InputSignal<((file: DataGridExport) => boolean | void) | undefined>;
+  /** Called before a copy puts text on the clipboard. Return `false` to take over (nothing is copied). The `copy` output fires first. */
+  readonly copyHandler: import("@angular/core/types/core").InputSignal<((copy: {
+    text: string;
+    rowCount: number;
+  }) => boolean | void) | undefined>;
+  /** Renders only the rows in view, in a scroll region of `height` px (needs `scroll`). */
+  readonly virtualize: import("@angular/core/types/core").InputSignal<{
+    rowHeight: number;
+    height: number;
+    overscan?: number;
+  } | undefined>;
+  /** Extra CSS class on the root. */
+  readonly className: import("@angular/core/types/core").InputSignal<string>;
+  /** Selected row ids. Two-way bindable: `[(selected)]`. */
+  readonly selected: import("@angular/core/types/core").ModelSignal<string[]>;
+  /** Text filter. Two-way bindable: `[(filter)]`. */
+  readonly filter: import("@angular/core/types/core").ModelSignal<string>;
+  /** Limits the text filter to one column: a column id, or `""` for every filterable column. Two-way bindable: `[(filterField)]`. */
+  readonly filterField: import("@angular/core/types/core").ModelSignal<string>;
+  /** Further sort keys after `sort`, for ties: Shift+click on another sortable header adds it. Two-way bindable: `[(thenBy)]`. */
+  readonly thenBy: import("@angular/core/types/core").ModelSignal<DataGridSort[]>;
+  /** Current sort. Two-way bindable: `[(sort)]`. */
+  readonly sort: import("@angular/core/types/core").ModelSignal<DataGridSort>;
+  /** Column ids in display order. Two-way bindable: `[(columnOrder)]`; columns it does not name follow in their `columns` order. */
+  readonly columnOrder: import("@angular/core/types/core").ModelSignal<string[]>;
+  /** Current 1-indexed page. Two-way bindable: `[(page)]`. */
+  readonly page: import("@angular/core/types/core").ModelSignal<number>;
+  readonly cellEdit: import("@angular/core/types/_api-chunk").OutputEmitterRef<DataGridCellEdit>;
+  readonly filesSelected: import("@angular/core/types/_api-chunk").OutputEmitterRef<{
+    rowId: string;
+    row: DataGridRow;
+    columnId: string;
+    files: File[];
+  }>;
+  readonly fileRemove: import("@angular/core/types/_api-chunk").OutputEmitterRef<{
+    rowId: string;
+    row: DataGridRow;
+    columnId: string;
+    fileId: string;
+  }>;
+  readonly rowActivate: import("@angular/core/types/_api-chunk").OutputEmitterRef<{
+    row: DataGridRow;
+    id: string;
+  }>;
+  readonly exportFile: import("@angular/core/types/_api-chunk").OutputEmitterRef<DataGridExport>;
+  readonly copy: import("@angular/core/types/_api-chunk").OutputEmitterRef<{
+    text: string;
+    rowCount: number;
+  }>;
+  protected readonly gridId: string;
+  protected readonly minColumnWidth = 40;
+  private readonly rootRef;
+  private readonly scrollRef;
+  private readonly injector;
+  protected readonly statusMessage: import("@angular/core/types/_chrome_dev_tools_performance-chunk").WritableSignal<string>;
+  protected readonly hiddenColumnIds: import("@angular/core/types/_chrome_dev_tools_performance-chunk").WritableSignal<ReadonlySet<string>>;
+  private readonly columnWidths;
+  private readonly focusedRow;
+  private readonly focusedCol;
+  private lastSelectedIndex;
+  protected readonly editingState: import("@angular/core/types/_chrome_dev_tools_performance-chunk").WritableSignal<Editing | null>;
+  private readonly scrollTop;
+  private draggingColumnId;
+  /** Each column with its type's defaults filled in under its own props. */
+  protected readonly resolvedColumns: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridColumn[]>;
+  protected readonly isGrid: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<boolean>;
+  protected readonly hasSelection: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<boolean>;
+  protected readonly colOffset: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<0 | 1>;
+  /** Columns in display order: those named in `columnOrder` first, the rest after in their own order. */
+  private readonly orderedColumns;
+  protected readonly visibleColumns: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridColumn[]>;
+  protected readonly hidableColumns: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridColumn[]>;
+  private readonly entries;
+  /** Each cell's value and formatted text, read once per row object and column (reset when the columns change). */
+  private readonly cellCache;
+  protected cellFor(column: DataGridColumn, row: DataGridRow): DataGridCellContext;
+  /** A missing value: `null`, `undefined` or an empty string. */
+  protected readonly isMissing: (value: unknown) => boolean;
+  /** A column the user can move: its own `movable`, else the grid's `movableColumns`. */
+  protected isMovable(column: DataGridColumn): boolean;
+  protected readonly filterableColumns: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridColumn[]>;
+  /** One folded (lower-case, no diacritics) text per filterable cell, built once per rows/columns change. */
+  private readonly searchIndex;
+  private readonly filteredEntries;
+  /** The sort keys in order: the primary, then `thenBy`, each with a real column and a direction. */
+  private readonly sortKeys;
+  protected readonly sortedEntries: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridEntry[]>;
+  protected readonly pageCount: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<number>;
+  protected readonly clampedPage: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<number>;
+  protected readonly pageStart: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<number>;
+  protected readonly pageEntries: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridEntry[]>;
+  protected readonly lastCol: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<number>;
+  protected readonly activeRow: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<number>;
+  protected readonly activeCol: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<number>;
+  protected readonly indexed: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<boolean>;
+  private readonly rowCount;
+  protected readonly renderItems: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<RenderItem[]>;
+  protected readonly scrollStyle: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<string | null>;
+  private readonly selectedSet;
+  protected readonly allSelected: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<boolean>;
+  protected readonly someSelected: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<boolean>;
+  protected readonly footerContext: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridFooterContext>;
+  protected readonly exportColumns: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridColumn[]>;
+  protected readonly exportEntries: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<DataGridEntry[]>;
+  protected readonly hasExportButtons: import("@angular/core/types/_chrome_dev_tools_performance-chunk").Signal<boolean>;
+  constructor();
+  private announce;
+  protected ariaSortFor(column: DataGridColumn): DataGridSortDirection | null;
+  /** 1 for the primary key, 2… for `thenBy`, only while more than one key is in force. */
+  protected sortOrderFor(column: DataGridColumn): number | null;
+  protected toggleSort(column: DataGridColumn, additive?: boolean): void;
+  protected setFilter(value: string): void;
+  /** Escape in the search field clears it. */
+  protected onFilterKeydown(event: Event): void;
+  protected onFilterFieldChange(event: Event): void;
+  protected isSelected(id: string): boolean;
+  private setSelected;
+  protected onRowSelectClick(index: number, event: Event): void;
+  /** `index` is the row's position in the sorted entries, not on the current page. */
+  private toggleRow;
+  protected toggleSelectAll(): void;
+  protected widthFor(column: DataGridColumn): number | undefined;
+  /** Inline style of a column's cells: its width, and its alignment where one is set. */
+  protected cellStyle(column: DataGridColumn): string | null;
+  private setWidth;
+  protected onResizeKeydown(column: DataGridColumn, event: Event): void;
+  protected onResizePointerDown(column: DataGridColumn, event: Event): void;
+  protected toggleColumnVisibility(columnId: string): void;
+  protected goToPage(next: number): void;
+  /** Move `columnId` to sit at `toVisibleIndex` among the visible columns. Returns whether it moved. */
+  private moveColumn;
+  protected onHeaderDragStart(column: DataGridColumn, event: Event): void;
+  protected onHeaderDragOver(event: Event): void;
+  protected onHeaderDrop(targetId: string, event: Event): void;
+  protected onScroll(event: Event): void;
+  /** Bring a body row into the scroll region. */
+  private revealRow;
+  private focusActiveCell;
+  private moveFocus;
+  /** One cell for an export: typed values stay typed, everything else is the text the grid shows. */
+  private exportCell;
+  private hasUtcColumn;
+  private buildExportTable;
+  /** Copy the export (what a download would hold) to the clipboard as tab-separated text. `copyHandler` may return false to take over. */
+  protected runCopy(): Promise<void>;
+  protected runExport(format: ExportFormat): void;
+  /** Files dropped on an editable file cell: the same report as the file input. The grid uploads nothing. */
+  protected onFileDragOver(column: DataGridColumn, event: Event): void;
+  protected onFileDrop(entry: DataGridEntry, column: DataGridColumn, event: Event): void;
+  protected onFileInput(entry: DataGridEntry, column: DataGridColumn, event: Event): void;
+  /** A cell the person can edit through the grid's edit model (not a rollup, a file cell with its own widgets, or a person cell with no editor). */
+  protected isEditable(column: DataGridColumn): boolean;
+  protected isEditingCell(entry: DataGridEntry, column: DataGridColumn): boolean;
+  protected startEdit(entry: DataGridEntry, column: DataGridColumn): void;
+  private parseDraft;
+  /** Two link values with the same address and label are the same edit. */
+  /** Accepted cell edits, for Ctrl/Cmd+Z. The consumer owns the data, so an undo is reported through the `cellEdit` output like any edit. */
+  private history;
+  /** Put an earlier cell value back, or re-apply it, through `cellEdit`. */
+  private stepHistory;
+  private isStructurallyEqual;
+  /** Validate and report one new value for a cell. Returns false (and keeps editing, if the editor is open) when it is refused. */
+  protected commitValue(entry: DataGridEntry, column: DataGridColumn, value: unknown): boolean;
+  private commitEdit;
+  private cancelEdit;
+  protected onEditorKeydown(event: Event): void;
+  protected onEditorBlur(): void;
+  /** Focus leaving the time-zone editor's pair (not moving between its two controls) commits. */
+  protected onZonedFocusout(event: Event): void;
+  protected setDraft(event: Event): void;
+  protected setZone(event: Event): void;
+  protected personEditorContext(entry: DataGridEntry, column: DataGridColumn, ctx: DataGridCellContext): DataGridPersonEditorContext;
+  private activateFocusedCell;
+  /** The widgets a consumer put in a body cell (never the grid's own controls). */
+  private widgetsIn;
+  private setWidgetTabindex;
+  private normaliseWidgets;
+  /** Focus the first widget of a cell; its widgets are tab stops while focus stays inside it. */
+  private enterCell;
+  private leaveCell;
+  /** Pointer or programmatic focus on a cell moves the roving position to it. */
+  protected onGridFocusin(event: Event): void;
+  protected onGridFocusout(event: Event): void;
+  /** A click on a body cell, outside any widget, activates its row. */
+  protected onGridClick(event: Event): void;
+  /** A double click on an editable body cell starts editing it. */
+  protected onGridDblclick(event: Event): void;
+  private typeahead;
+  protected onGridKeydown(event: Event): void;
+  private restoreView;
+  protected rowLabelOf(entry: DataGridEntry): string;
+  protected cellClassOf(column: DataGridColumn, ctx: DataGridCellContext): string;
+  protected peopleIn(value: unknown): DataGridPerson[];
+  protected shownPeople(column: DataGridColumn, value: unknown): DataGridPerson[];
+  protected nameOf(person: DataGridPerson): string;
+  protected filesIn(value: unknown): DataGridFile[];
+  protected linkIn(value: unknown): DataGridLink | null;
+  protected hrefOf(href: string | undefined): string | null;
+  protected stringOf(value: unknown): string;
+  protected ungroupedOptions(column: DataGridColumn): DataGridOption[];
+  protected groupsOf(column: DataGridColumn): string[];
+  protected optionsInGroup(column: DataGridColumn, group: string): DataGridOption[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<DataGrid, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DataGrid, "lily-data-grid", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "caption": {
+      "alias": "caption";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": true;
+      "isSignal": true;
+    };
+    "rows": {
+      "alias": "rows";
+      "required": true;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyValue": {
+      "alias": "emptyValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "warnMissingLabels": {
+      "alias": "warnMissingLabels";
+      "required": false;
+      "isSignal": true;
+    };
+    "nulls": {
+      "alias": "nulls";
+      "required": false;
+      "isSignal": true;
+    };
+    "movableColumns": {
+      "alias": "movableColumns";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowFilter": {
+      "alias": "rowFilter";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowId": {
+      "alias": "rowId";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectionMode": {
+      "alias": "selectionMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "storageKey": {
+      "alias": "storageKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowClass": {
+      "alias": "rowClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowAttrs": {
+      "alias": "rowAttrs";
+      "required": false;
+      "isSignal": true;
+    };
+    "activateRows": {
+      "alias": "activateRows";
+      "required": false;
+      "isSignal": true;
+    };
+    "empty": {
+      "alias": "empty";
+      "required": false;
+      "isSignal": true;
+    };
+    "footer": {
+      "alias": "footer";
+      "required": false;
+      "isSignal": true;
+    };
+    "busy": {
+      "alias": "busy";
+      "required": false;
+      "isSignal": true;
+    };
+    "scroll": {
+      "alias": "scroll";
+      "required": false;
+      "isSignal": true;
+    };
+    "exportFilename": {
+      "alias": "exportFilename";
+      "required": false;
+      "isSignal": true;
+    };
+    "exportScope": {
+      "alias": "exportScope";
+      "required": false;
+      "isSignal": true;
+    };
+    "exportFormulas": {
+      "alias": "exportFormulas";
+      "required": false;
+      "isSignal": true;
+    };
+    "exportHandler": {
+      "alias": "exportHandler";
+      "required": false;
+      "isSignal": true;
+    };
+    "copyHandler": {
+      "alias": "copyHandler";
+      "required": false;
+      "isSignal": true;
+    };
+    "virtualize": {
+      "alias": "virtualize";
+      "required": false;
+      "isSignal": true;
+    };
+    "className": {
+      "alias": "className";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "filter": {
+      "alias": "filter";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterField": {
+      "alias": "filterField";
+      "required": false;
+      "isSignal": true;
+    };
+    "thenBy": {
+      "alias": "thenBy";
+      "required": false;
+      "isSignal": true;
+    };
+    "sort": {
+      "alias": "sort";
+      "required": false;
+      "isSignal": true;
+    };
+    "columnOrder": {
+      "alias": "columnOrder";
+      "required": false;
+      "isSignal": true;
+    };
+    "page": {
+      "alias": "page";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selected": "selectedChange";
+    "filter": "filterChange";
+    "filterField": "filterFieldChange";
+    "thenBy": "thenByChange";
+    "sort": "sortChange";
+    "columnOrder": "columnOrderChange";
+    "page": "pageChange";
+    "cellEdit": "cellEdit";
+    "filesSelected": "filesSelected";
+    "fileRemove": "fileRemove";
+    "rowActivate": "rowActivate";
+    "exportFile": "exportFile";
+    "copy": "copy";
+  }, never, never, true, never>;
+}
+/**
+ * Search matching shared by the data grid, kanban board, Gantt chart and calendar: pure, so it is unit-tested without a browser.
+ *
+ * A query is split on whitespace into terms; every term must appear (AND), in any order, ignoring case and diacritics
+ * ("cafe" finds "Café"). An empty query matches everything.
+ */
+/** Lower-case and strip combining marks, so matching ignores case and diacritics. */
+export declare function foldText(text: string): string;
+/** The terms of a query, folded; empty when the query is blank. */
+export declare function searchTerms(query: string): string[];
+/** True when every term of `query` appears in `text`. */
+export declare function matchesSearch(text: string, query: string): boolean;
+type SearchSegment = {
+  text: string;
+  match: boolean;
+};
+/**
+ * `text` cut into runs, marking the parts any term matches (for `<mark>`). Folding can change a string's length (a precomposed "é"
+ * is one character, its folded form too, but a ligature may not be), so matching works on a per-character fold and falls back to
+ * one unmarked segment if the two ever disagree.
+ */
+export declare function highlightSegments(text: string, query: string): SearchSegment[];
+export declare const TYPEAHEAD_RESET_MS = 700;
+type TypeaheadState = {
+  prefix: string;
+  at: number;
+};
+/** Whether a key press is a type-ahead character: one printable character, no Ctrl, Alt or Meta. */
+export declare function isTypeaheadKey(event: {
+  key: string;
+  ctrlKey?: boolean;
+  altKey?: boolean;
+  metaKey?: boolean;
+}): boolean;
+/** The prefix after `key` is pressed at time `now`: it grows while presses are within `resetMs` of each other, else starts over. */
+export declare function nextTypeaheadState(previous: TypeaheadState, key: string, now: number, resetMs?: number): TypeaheadState;
+/**
+ * The index of the row to move to, or -1. Searches from the row after `from` and wraps. A prefix of one repeated letter ("ss") is
+ * treated as that single letter, so pressing it again steps through the rows starting with it.
+ */
+export declare function findTypeaheadMatch(labels: readonly string[], from: number, prefix: string): number;
+/**
+ * Undo / redo for typed-field edits: pure, so it is unit-tested without a browser. The components own nothing but the stacks:
+ * the consumer owns the data, so an undo is reported the same way an edit is — through `onFieldEdit`, with the earlier value.
+ */
+/** One accepted edit: which record and field, the value it took and the value it replaced. */
+type EditRecord = {
+  ownerId: string;
+  fieldId: string;
+  value: unknown;
+  previous: unknown;
+};
+type EditHistory = {
+  undo: readonly EditRecord[];
+  redo: readonly EditRecord[];
+};
+export declare const EMPTY_HISTORY: EditHistory;
+/** Most steps kept; the oldest fall off. */
+export declare const HISTORY_LIMIT = 100;
+/** A new edit goes on the undo stack and ends any redo chain. */
+export declare function recordEdit(history: EditHistory, record: EditRecord, limit?: number): EditHistory;
+/** Step back: the record to reverse (apply `previous`), and the history with it moved to the redo stack. */
+export declare function undoEdit(history: EditHistory): {
+  history: EditHistory;
+  record: EditRecord | undefined;
+};
+/** Step forward: the record to re-apply (apply `value`), and the history with it moved back to the undo stack. */
+export declare function redoEdit(history: EditHistory): {
+  history: EditHistory;
+  record: EditRecord | undefined;
+};
+/** Whether a key press is Undo (Ctrl/Cmd+Z) or Redo (Ctrl/Cmd+Shift+Z, or Ctrl+Y), or neither. */
+export declare function historyKey(event: {
+  key: string;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+}): "undo" | "redo" | null;
+/**
+ * Which `labels` a grid needs, by what it renders — so an app can check that it has supplied every string for its locale, and a
+ * grid can say, in development, which control it is about to leave unnamed. Lily ships no English: a missing label is a control with
+ * no name, or an announcement that is never made, never English text. Pure, so it is unit-tested on its own.
+ */
+/** What the grid is showing, as far as labels are concerned. */
+type LabelFeatures = {
+  /** `selectionMode` is not `none`. */
+  selection?: boolean;
+  /** `pageSize` is set. */
+  pagination?: boolean;
+  /** Some column is `hidable`. */
+  hidableColumns?: boolean;
+  /** Some column is `resizable`. */
+  resizableColumns?: boolean;
+  /** Some column is editable (`onCellEdit` is set). */
+  editing?: boolean;
+  /** Some column is `sortable`. */
+  sorting?: boolean;
+  /** The search field is wanted (the field itself is gated by `labels.search`). */
+  search?: boolean;
+  /** Export or copy buttons are wanted. */
+  exporting?: boolean;
+};
+/** Labels that **name a control**: without one the control is unnamed to a screen reader (or not rendered at all). */
+export declare const CONTROL_LABELS: {
+  readonly selection: readonly ["selectAll", "selectionColumn", "selectRow"];
+  readonly pagination: readonly ["previousPage", "nextPage", "pageStatus"];
+  readonly hidableColumns: readonly ["columnVisibility", "columnVisibilityOption"];
+  readonly resizableColumns: readonly ["resizeHandle"];
+  readonly editing: readonly ["editCell", "cellEditor"];
+  readonly search: readonly ["search"];
+  readonly exporting: readonly ["export"];
+};
+/** Labels that make an **announcement** through the live region: without one the change is silent. */
+export declare const ANNOUNCEMENT_LABELS: {
+  readonly sorting: readonly ["sortAnnouncement"];
+  readonly search: readonly ["filterAnnouncement"];
+  readonly selection: readonly ["selectionAnnouncement"];
+  readonly pagination: readonly ["pageAnnouncement"];
+  readonly editing: readonly ["editAnnouncement", "editCancelAnnouncement", "editError", "undoAnnouncement", "redoAnnouncement"];
+  readonly exporting: readonly ["exportAnnouncement", "copyAnnouncement", "copyFailed"];
+};
+type LabelKind = "control" | "announcement";
+/** Every label key the features in use call for, with its kind. */
+export declare function requiredLabels(features: LabelFeatures): {
+  key: string;
+  kind: LabelKind;
+}[];
+/** The required labels that are absent (`undefined`, `null` or an empty string) from `labels`. */
+export declare function missingLabels(features: LabelFeatures, labels: Record<string, unknown> | undefined): {
+  key: string;
+  kind: LabelKind;
+}[];
+export type { DataGridAggregate, DataGridCellContext, DataGridCellEdit, DataGridCellType, DataGridColumn, DataGridEntry, DataGridExport, DataGridFile, DataGridFooterContext, DataGridFormulaContext, DataGridFormulaResult, DataGridLabels, DataGridLink, DataGridOption, DataGridPerson, DataGridPersonEditorContext, DataGridRow, DataGridSelectionMode, DataGridSort, DataGridSortDirection, DataGridZonedTime, DelimitedOptions, EditHistory, EditRecord, ExportFormat, ExportFormula, ExportTable, LabelFeatures, LabelKind, SearchSegment, TypeaheadState, XlsxOptions };
+//# sourceMappingURL=lilydesignsystem-angular-data-grid.d.ts.map