@lifecorner/angular-ui-kit 3.4.1 → 3.5.0

package/types/lifecorner-angular-ui-kit-table.d.ts

@@ -0,0 +1,632 @@
+import * as i0 from "@angular/core";
+import { QueryList, TemplateRef } from "@angular/core";
+import { ButtonVariant } from "@lifecorner/angular-ui-kit/button";
+/**
+ * Directive for defining custom cell templates in the Table component.
+ *
+ * @example
+ * ```html
+ * <lc-table [columns]="columns" [data]="data">
+ *   <ng-template lcTableCell="status" let-row>
+ *     <lc-badge [variant]="row.status">{{ row.status }}</lc-badge>
+ *   </ng-template>
+ * </lc-table>
+ * ```
+ */
+export declare class TableCellDirective {
+  /** The column key this template applies to */
+  readonly columnKey: import("@angular/core").InputSignal<string>;
+  template: TemplateRef<any>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "[lcTableCell]", never, {
+    "columnKey": {
+      "alias": "lcTableCell";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+type TableCellClass = string | ((value: unknown, row: Record<string, unknown>, column: TableColumn, rowIndex: number) => string);
+type TableCellStyle = Record<string, string> | ((value: unknown, row: Record<string, unknown>, column: TableColumn, rowIndex: number) => Record<string, string>);
+export interface TableColumn {
+  key: string;
+  label: string;
+  sortable?: boolean;
+  filterable?: boolean;
+  editable?: boolean;
+  width?: string;
+  /** Optional CSS class(es) applied to both th and td cells */
+  cssClass?: string;
+  /** Optional CSS class(es) for td cells only (string or resolver callback) */
+  cellClass?: TableCellClass;
+  /** Optional inline styles for td cells only (object or resolver callback) */
+  cellStyle?: TableCellStyle;
+  /** Optional tooltip shown on hover over the column header */
+  tooltip?: string;
+  /** Optional formatter for cell output when no custom template is used */
+  formatter?: (value: unknown, row: Record<string, unknown>, column: TableColumn, rowIndex: number) => unknown;
+  /** Input type for inline editing (default: text) */
+  editType?: 'text' | 'number' | 'select';
+  /** Options for select edit type */
+  editOptions?: string[];
+}
+/**
+ * A row-level action rendered in the table's actions column (e.g. Freigeben, Ablehnen).
+ * Action button clicks never trigger the row's `rowClick` output.
+ */
+export interface TableAction {
+  /** Unique identifier emitted with the {@link ActionClickEvent} */
+  key: string;
+  /** Visible button label (omit for icon-only buttons when an `icon` is set) */
+  label?: string;
+  /** Optional icon name rendered before the label */
+  icon?: string;
+  /** Button variant (default: 'ghost') */
+  variant?: ButtonVariant;
+  /** Optional tooltip / aria-label, useful for icon-only actions */
+  tooltip?: string;
+  /** Hide this action for specific rows */
+  hidden?: (row: Record<string, unknown>, rowIndex: number) => boolean;
+  /** Disable this action for specific rows */
+  disabled?: (row: Record<string, unknown>, rowIndex: number) => boolean;
+}
+export type TableActionsAlign = 'start' | 'center' | 'end';
+export interface ActionClickEvent {
+  action: string;
+  row: Record<string, unknown>;
+  rowIndex: number;
+}
+export interface SortEvent {
+  column: string;
+  direction: 'asc' | 'desc';
+}
+export interface CellEditEvent {
+  row: Record<string, unknown>;
+  column: string;
+  oldValue: unknown;
+  newValue: unknown;
+  /** Index of `row` in the `data` input (not its position on screen). */
+  rowIndex: number;
+}
+export interface SelectionChangeEvent {
+  selected: Record<string, unknown>[];
+  allSelected: boolean;
+}
+/** Emitted when a parent (group) row is expanded or collapsed in tree mode. */
+export interface RowToggleEvent {
+  id: string;
+  expanded: boolean;
+  row: Record<string, unknown>;
+}
+/**
+ * Configuration that enables hierarchical (tree / grouped) rows. Mirrors the
+ * discrete `idKey` / `parentKey` / `treeColumn` inputs and is exported for
+ * consumers that prefer to pass a single config object around.
+ */
+export interface TableTreeConfig {
+  idKey: string;
+  parentKey: string;
+  treeColumn?: string;
+}
+export type TableVariant = 'default' | 'striped' | 'bordered';
+export type TableSize = 'sm' | 'md' | 'lg';
+/**
+ * Internal, render-ready view-model for a single visible table row. In flat
+ * mode every row is depth 0 with no tree adornments; in tree mode it carries
+ * the disclosure / indentation / aria metadata for the row.
+ */
+interface DisplayRow {
+  /** The underlying data object. */
+  row: Record<string, unknown>;
+  /**
+   * The row's index into `data()` — in both modes. It is what action, class,
+   * style and formatter callbacks receive as `rowIndex`, and what identifies
+   * the row in `CellEditEvent`. (It used to be the *positional* index in flat
+   * mode — page offset plus row position — which, once a sort or filter was
+   * active, pointed at a different row of `data()` than the one on screen.)
+   */
+  absIndex: number;
+  /**
+   * What selection and inline editing are keyed by: the row's `idKey` value
+   * when the table has one, otherwise the row object itself. Either survives a
+   * re-sort, a filter and a page change; an id also survives the parent
+   * replacing its data array with fresh objects.
+   */
+  key: unknown;
+  /** Row id (tree mode only; `null` in flat mode). */
+  id: string | null;
+  /** Tree depth — 0 for roots and for every row in flat mode. */
+  depth: number;
+  /** 1-based depth, surfaced as `aria-level` in tree mode. */
+  level: number;
+  /** Whether this row has visible children (renders a chevron). */
+  hasChildren: boolean;
+  /** Whether this parent row is currently expanded. */
+  expanded: boolean;
+  /** 1-based position within its sibling group (`aria-posinset`). */
+  posInSet: number;
+  /** Size of its sibling group (`aria-setsize`). */
+  setSize: number;
+}
+/**
+ * Table component for displaying structured data in rows and columns.
+ *
+ * Features:
+ * - Column-based sorting with sort direction indicators
+ * - Variant styles (default, striped, bordered)
+ * - Size presets (sm, md, lg)
+ * - Hoverable row highlighting
+ * - Per-column formatter callbacks for display values
+ * - Per-cell class/style callbacks for conditional styling
+ * - Custom cell templates via content projection
+ * - Composed cells (e.g. avatar + badge + actions)
+ * - Hierarchical "tree" rows (grouped / expandable) via `idKey` + `parentKey`
+ * - Responsive horizontal scrolling
+ * - Empty state text for no data
+ * - Accessible with proper table semantics
+ *
+ * @example
+ * ```html
+ * <lc-table [columns]="columns" [data]="data" variant="striped" [hoverable]="true"
+ *   (sort)="onSort($event)" (rowClick)="onRowClick($event)" />
+ * ```
+ *
+ * @example
+ * ```ts
+ * columns: TableColumn[] = [
+ *   {
+ *     key: 'amount',
+ *     label: 'Amount',
+ *     formatter: (value) => new Intl.NumberFormat('de-DE', {
+ *       style: 'currency',
+ *       currency: 'EUR',
+ *     }).format(Number(value ?? 0)),
+ *   },
+ * ];
+ * ```
+ */
+export declare class TableComponent {
+  /** Custom cell templates */
+  cellTemplates: QueryList<TableCellDirective>;
+  /** Array of column definitions */
+  columns: import("@angular/core").InputSignal<TableColumn[]>;
+  /** Array of data objects to display */
+  data: import("@angular/core").InputSignal<Record<string, unknown>[]>;
+  /** Visual variant of the table */
+  variant: import("@angular/core").InputSignal<TableVariant>;
+  /** Size of the table */
+  size: import("@angular/core").InputSignal<TableSize>;
+  /** Whether rows should highlight on hover */
+  hoverable: import("@angular/core").InputSignal<boolean>;
+  /** Whether table should be responsive (horizontal scroll on mobile) */
+  responsive: import("@angular/core").InputSignal<boolean>;
+  /** Text shown when data is empty */
+  emptyText: import("@angular/core").InputSignal<string>;
+  /** Placeholder prefix of the column filters, followed by the column label (`filterable`). */
+  filterPlaceholderLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the select-all checkbox (`selectable`). */
+  selectAllAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible name of a row checkbox, followed by the row number. */
+  selectRowAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Screen-reader state of a column sorted ascending. */
+  sortedAscendingLabel: import("@angular/core").InputSignal<string>;
+  /** Screen-reader state of a column sorted descending. */
+  sortedDescendingLabel: import("@angular/core").InputSignal<string>;
+  /** Tree mode: accessible name prefix of the expand toggle, followed by the row label. */
+  expandRowAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Tree mode: accessible name prefix of the collapse toggle, followed by the row label. */
+  collapseRowAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Pagination: word between the shown range and the total (`1–10 of 42`). */
+  rangeOfLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the page-size select. */
+  rowsPerPageAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the previous-page button. */
+  previousPageAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the next-page button. */
+  nextPageAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Enable pagination */
+  paginate: import("@angular/core").InputSignal<boolean>;
+  /** Rows per page */
+  pageSize: import("@angular/core").InputSignal<number>;
+  /** Available page size options */
+  pageSizeOptions: import("@angular/core").InputSignal<number[]>;
+  /** Enable row selection checkboxes */
+  selectable: import("@angular/core").InputSignal<boolean>;
+  /** Enable per-column text filters */
+  filterable: import("@angular/core").InputSignal<boolean>;
+  /** Enable inline cell editing on double-click */
+  editable: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Row-level actions rendered in a trailing actions column (e.g. Freigeben / Ablehnen).
+   * Clicking an action button does NOT trigger the row's `rowClick` output.
+   */
+  actions: import("@angular/core").InputSignal<TableAction[]>;
+  /** Header label for the actions column */
+  actionsLabel: import("@angular/core").InputSignal<string>;
+  /** Width of the actions column (e.g. '120px') */
+  actionsWidth: import("@angular/core").InputSignal<string | undefined>;
+  /** Horizontal alignment of the action buttons (and header label) within the cell */
+  actionsAlign: import("@angular/core").InputSignal<TableActionsAlign>;
+  /**
+   * Row field holding the unique id. Required (together with {@link parentKey})
+   * to enable hierarchical "tree mode". Absent ⇒ today's flat table.
+   */
+  idKey: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * Row field referencing the parent row's id. Presence of both `idKey` and
+   * `parentKey` enables tree mode. Rows with an absent/empty or unknown parent
+   * id are treated as roots.
+   */
+  parentKey: import("@angular/core").InputSignal<string | undefined>;
+  /** Column key the chevron + indentation attach to. Default: first column. */
+  treeColumn: import("@angular/core").InputSignal<string | undefined>;
+  /** Initial expand state for all parent rows when uncontrolled. Default: true. */
+  defaultExpanded: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Controlled set of expanded parent ids. When provided, the table renders
+   * exactly these as expanded; combine with {@link expandedIdsChange} for
+   * `[(expandedIds)]`. When omitted, expansion is uncontrolled and seeded by
+   * {@link defaultExpanded}.
+   */
+  expandedIds: import("@angular/core").InputSignal<string[] | undefined>;
+  /** Indentation per depth level, in px. Default: 20. */
+  indentSize: import("@angular/core").InputSignal<number>;
+  /** Accessible name prefix of a column filter, followed by the column label. */
+  filterAriaLabel: import("@angular/core").InputSignal<string>;
+  /** Emitted when a sortable column header is clicked */
+  readonly sort: import("@angular/core").OutputEmitterRef<SortEvent>;
+  /** Emitted when a row is clicked */
+  readonly rowClick: import("@angular/core").OutputEmitterRef<Record<string, unknown>>;
+  /** Emitted when a cell is edited */
+  readonly cellEdit: import("@angular/core").OutputEmitterRef<CellEditEvent>;
+  /** Emitted when row selection changes */
+  readonly selectionChange: import("@angular/core").OutputEmitterRef<SelectionChangeEvent>;
+  /** Emitted when a row action button is clicked */
+  readonly actionClick: import("@angular/core").OutputEmitterRef<ActionClickEvent>;
+  /** Emitted when a parent row is expanded/collapsed (tree mode). */
+  readonly rowToggle: import("@angular/core").OutputEmitterRef<RowToggleEvent>;
+  /** Emitted with the full list of expanded parent ids; enables `[(expandedIds)]`. */
+  readonly expandedIdsChange: import("@angular/core").OutputEmitterRef<string[]>;
+  protected currentSort: import("@angular/core").WritableSignal<{
+    column: string;
+    direction: "asc" | "desc";
+  } | null>;
+  /**
+   * Effective page size. Seeded from the `pageSize` input (resetting if it
+   * changes) and overridable by the user via the page-size dropdown.
+   */
+  protected internalPageSize: import("@angular/core").WritableSignal<number>;
+  /**
+   * Current page, kept within range: when the data shrinks or the page size
+   * grows so that the page no longer exists, it moves back to the last one
+   * (rather than showing an empty page captioned "31–30 of 30").
+   */
+  protected currentPage: import("@angular/core").WritableSignal<number>;
+  /**
+   * Selected row keys (see `DisplayRow.key`). Pruned when `data` changes, so
+   * a key whose row is gone doesn't linger and count towards "all selected".
+   */
+  protected selectedRows: import("@angular/core").WritableSignal<Set<unknown>>;
+  protected columnFilters: import("@angular/core").WritableSignal<Record<string, string>>;
+  protected editingCell: import("@angular/core").WritableSignal<{
+    key: unknown;
+    column: string;
+  } | null>;
+  protected editValue: import("@angular/core").WritableSignal<string>;
+  /** The inline-edit input while a cell is being edited. */
+  private readonly editInput;
+  private focusedEditInput;
+  constructor();
+  /** The key of every row currently in `data()`. */
+  private readonly rowKeys;
+  /** See `DisplayRow.key`. */
+  private rowKey;
+  /** User expand/collapse overrides keyed by row id (uncontrolled mode). */
+  private readonly expandOverrides;
+  /**
+   * Filtered data (applies column filters)
+   */
+  protected readonly filteredData: import("@angular/core").Signal<Record<string, unknown>[]>;
+  /** Comparator for the active sort, shared by flat sorting and tree sibling sorting. */
+  private rowComparator;
+  /**
+   * Sorted data
+   */
+  protected readonly sortedData: import("@angular/core").Signal<Record<string, unknown>[]>;
+  /**
+   * Paginated data (or all if pagination disabled). Flat mode only.
+   */
+  protected readonly displayData: import("@angular/core").Signal<Record<string, unknown>[]>;
+  /** Whether hierarchical tree mode is active. */
+  protected readonly treeMode: import("@angular/core").Signal<boolean>;
+  /** Column the chevron + indentation attach to (defaults to the first column). */
+  protected readonly effectiveTreeColumn: import("@angular/core").Signal<string>;
+  /** Stable map of row object → its index in `data()` (row identity for tree mode). */
+  private readonly dataIndexMap;
+  /** Parent → ordered children index built from `idKey`/`parentKey`. */
+  private readonly treeBuild;
+  /**
+   * Tree restricted to rows that match the active filters together with their
+   * ancestor chain (so the path to a match stays visible).
+   */
+  private readonly treeFiltered;
+  /** Tree with each sibling group sorted by the active sort (structure kept intact). */
+  private readonly treeSorted;
+  /** Root rows after filter/sort — the unit of pagination in tree mode. */
+  private readonly treeRoots;
+  /**
+   * Render-ready rows. In flat mode this wraps the existing paginated data; in
+   * tree mode it paginates roots and flattens each visible (expanded) subtree.
+   */
+  protected readonly displayRows: import("@angular/core").Signal<DisplayRow[]>;
+  /** Total pages */
+  protected readonly totalPages: import("@angular/core").Signal<number>;
+  /**
+   * Pagination row count. Tree mode counts root rows (the paginated unit); flat
+   * mode counts filtered rows.
+   */
+  protected readonly totalRows: import("@angular/core").Signal<number>;
+  /** Whether all visible rows are selected */
+  protected readonly allSelected: import("@angular/core").Signal<boolean>;
+  /** Whether some, but not all, visible rows are selected — the header box's mixed state. */
+  protected readonly someSelected: import("@angular/core").Signal<boolean>;
+  protected readonly pageSizeSelectOptions: import("@angular/core").Signal<{
+    value: number;
+    label: string;
+  }[]>;
+  /**
+   * Computed CSS classes for the table element
+   */
+  tableClasses: import("@angular/core").Signal<string>;
+  /**
+   * Computed CSS classes for the wrapper element
+   */
+  wrapperClasses: import("@angular/core").Signal<string>;
+  handleSort(columnKey: string): void;
+  getSortState(columnKey: string): 'asc' | 'desc' | null;
+  getAriaSort(columnKey: string): string | null;
+  getHeaderClasses(column: TableColumn): string;
+  getCellValue(row: Record<string, unknown>, columnKey: string): unknown;
+  getFormattedCellValue(row: Record<string, unknown>, column: TableColumn, rowIndex: number): unknown;
+  getCellClasses(row: Record<string, unknown>, column: TableColumn, rowIndex: number): string;
+  getCellStyles(row: Record<string, unknown>, column: TableColumn, rowIndex: number): Record<string, string> | null;
+  /** Whether the given column is the disclosure/indent column in tree mode. */
+  protected isTreeColumn(columnKey: string): boolean;
+  /** Indent levels to render before a row's chevron (one guide per ancestor depth). */
+  protected indentLevels(depth: number): number[];
+  /** Accessible name for a row's disclosure button (the tree column's value). */
+  protected treeCellLabel(row: Record<string, unknown>): string;
+  getCellTemplate(columnKey: string): TableCellDirective | undefined;
+  hasCustomTemplate(columnKey: string): boolean;
+  onRowClick(row: Record<string, unknown>): void;
+  /** Whether the trailing actions column should be rendered */
+  protected readonly hasActions: import("@angular/core").Signal<boolean>;
+  protected isActionHidden(action: TableAction, row: Record<string, unknown>, rowIndex: number): boolean;
+  protected isActionDisabled(action: TableAction, row: Record<string, unknown>, rowIndex: number): boolean;
+  /**
+   * Handles an action button click. The DOM click is stopped from propagating
+   * (see template `$event.stopPropagation()`), so the row's `rowClick` never fires.
+   */
+  protected onActionClick(action: TableAction, row: Record<string, unknown>, rowIndex: number): void;
+  private readonly rowEls;
+  private readonly focusedRowKey;
+  /** Key of the row that holds the tab stop. */
+  private readonly effectiveFocusedKey;
+  protected rowTabindex(dr: DisplayRow): number | null;
+  protected onRowFocus(dr: DisplayRow): void;
+  protected onRowKeydown(event: KeyboardEvent, dr: DisplayRow): void;
+  private focusRow;
+  /** Whether the parent row with the given id is currently expanded. */
+  protected isExpanded(id: string): boolean;
+  /** Chevron click: toggle expand state without triggering the row click. */
+  protected onChevronClick(displayRow: DisplayRow, event: Event): void;
+  private toggleRow;
+  /** The full list of expanded parent ids after applying a single toggle. */
+  private nextExpandedIds;
+  protected goToPage(page: number): void;
+  protected onPageSizeChange(event: Event): void;
+  protected onPageSizeModelChange(value: string | number | null): void;
+  protected get paginationStart(): number;
+  protected get paginationEnd(): number;
+  protected toggleSelectAll(): void;
+  protected toggleRowSelect(row: Record<string, unknown>): void;
+  protected isRowSelected(row: Record<string, unknown>): boolean;
+  private emitSelectionChange;
+  protected onFilterChange(columnKey: string, value: string): void;
+  protected getFilterValue(columnKey: string): string;
+  protected startEdit(row: Record<string, unknown>, column: string, currentValue: unknown): void;
+  protected isEditing(row: Record<string, unknown>, column: string): boolean;
+  protected commitEdit(row: Record<string, unknown>, column: string): void;
+  protected cancelEdit(): void;
+  protected onEditKeydown(event: KeyboardEvent, row: Record<string, unknown>, column: string): void;
+  /** Enter/Space on a focused sortable header sorts, like a click does. */
+  protected onHeaderKeydown(event: KeyboardEvent, columnKey: string): void;
+  protected getInputValue(event: Event): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "lc-table", never, {
+    "columns": {
+      "alias": "columns";
+      "required": false;
+      "isSignal": true;
+    };
+    "data": {
+      "alias": "data";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "hoverable": {
+      "alias": "hoverable";
+      "required": false;
+      "isSignal": true;
+    };
+    "responsive": {
+      "alias": "responsive";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterPlaceholderLabel": {
+      "alias": "filterPlaceholderLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectAllAriaLabel": {
+      "alias": "selectAllAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectRowAriaLabel": {
+      "alias": "selectRowAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortedAscendingLabel": {
+      "alias": "sortedAscendingLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "sortedDescendingLabel": {
+      "alias": "sortedDescendingLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandRowAriaLabel": {
+      "alias": "expandRowAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapseRowAriaLabel": {
+      "alias": "collapseRowAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "rangeOfLabel": {
+      "alias": "rangeOfLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "rowsPerPageAriaLabel": {
+      "alias": "rowsPerPageAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "previousPageAriaLabel": {
+      "alias": "previousPageAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "nextPageAriaLabel": {
+      "alias": "nextPageAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "paginate": {
+      "alias": "paginate";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSizeOptions": {
+      "alias": "pageSizeOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "selectable": {
+      "alias": "selectable";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterable": {
+      "alias": "filterable";
+      "required": false;
+      "isSignal": true;
+    };
+    "editable": {
+      "alias": "editable";
+      "required": false;
+      "isSignal": true;
+    };
+    "actions": {
+      "alias": "actions";
+      "required": false;
+      "isSignal": true;
+    };
+    "actionsLabel": {
+      "alias": "actionsLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "actionsWidth": {
+      "alias": "actionsWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "actionsAlign": {
+      "alias": "actionsAlign";
+      "required": false;
+      "isSignal": true;
+    };
+    "idKey": {
+      "alias": "idKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "parentKey": {
+      "alias": "parentKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "treeColumn": {
+      "alias": "treeColumn";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultExpanded": {
+      "alias": "defaultExpanded";
+      "required": false;
+      "isSignal": true;
+    };
+    "expandedIds": {
+      "alias": "expandedIds";
+      "required": false;
+      "isSignal": true;
+    };
+    "indentSize": {
+      "alias": "indentSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "filterAriaLabel": {
+      "alias": "filterAriaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "sort": "sort";
+    "rowClick": "rowClick";
+    "cellEdit": "cellEdit";
+    "selectionChange": "selectionChange";
+    "actionClick": "actionClick";
+    "rowToggle": "rowToggle";
+    "expandedIdsChange": "expandedIdsChange";
+  }, ["cellTemplates"], never, true, never>;
+}
+export {};