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

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

@@ -0,0 +1,811 @@
+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;
+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. */
+  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;
+  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>;
+  /** 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>;
+  /** 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>;
+  /** 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>;
+  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;
+  /** Lowercased search text per row, built once per rows/columns change. */
+  private readonly searchIndex;
+  private readonly filteredEntries;
+  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;
+  protected toggleSort(column: DataGridColumn): void;
+  protected onFilterInput(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;
+  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. */
+  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;
+  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;
+    };
+    "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;
+    };
+    "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;
+    };
+    "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";
+    "sort": "sortChange";
+    "columnOrder": "columnOrderChange";
+    "page": "pageChange";
+    "cellEdit": "cellEdit";
+    "filesSelected": "filesSelected";
+    "fileRemove": "fileRemove";
+    "rowActivate": "rowActivate";
+    "exportFile": "exportFile";
+  }, never, never, true, never>;
+}
+export type { DataGridAggregate, DataGridCellContext, DataGridCellEdit, DataGridCellType, DataGridColumn, DataGridEntry, DataGridExport, DataGridFile, DataGridFooterContext, DataGridFormulaContext, DataGridFormulaResult, DataGridLabels, DataGridLink, DataGridOption, DataGridPerson, DataGridPersonEditorContext, DataGridRow, DataGridSelectionMode, DataGridSort, DataGridSortDirection, DataGridZonedTime, DelimitedOptions, ExportFormat, ExportFormula, ExportTable, XlsxOptions };
+//# sourceMappingURL=lilydesignsystem-angular-data-grid.d.ts.map