@reforgium/data-grid 1.1.0 → 2.0.1

package/types/reforgium-data-grid.d.ts

@@ -1,12 +1,13 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, ElementRef } from '@angular/core';
+import { TemplateRef, InjectionToken, EnvironmentProviders, ElementRef } from '@angular/core';
+import * as _reforgium_data_grid from '@reforgium/data-grid';
 
 /**
  * Directive for defining type-specific cell templates in a data grid.
  *
  * This directive allows developers to create custom cell renderers for specific data types
  * within the data grid component. It binds a template to a type identifier, enabling
- * the grid to dynamically select and render the appropriate template based on column type.
+ * the grid to dynamically select and render the appropriate template based on a column type.
  *
  * Example usage:
  * ```html
@@ -81,6 +82,356 @@ declare class DataGridHeaderTemplateDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridHeaderTemplateDirective, "ng-template[reDataGridHeader]", never, { "key": { "alias": "reDataGridHeader"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Represents a key of an object that is also a string, or any string.
+ * Used for identifying data properties in rows.
+ */
+type DataKey<Data> = (keyof Data & string) | string;
+/**
+ * Function type that resolves a value of type `Return` from an argument of type `Arg`.
+ * Often used to transform row data or extract specific properties.
+ */
+type KeyResolver<Arg = AnyType, Return = string> = (arg: Arg) => Return;
+/**
+ * Union type for row identification.
+ * Can be either a property key (string) or a resolver function.
+ */
+type RowKeyFn<Data> = DataKey<Data> | KeyResolver<Data, string | number>;
+/**
+ * Type alias for `any`.
+ */
+type AnyType = any;
+/**
+ * Represents an object with string keys and values of any type.
+ * Common base type for row data.
+ */
+type AnyDict = Record<string, AnyType>;
+
+/**
+ * Horizontal alignment options for grid cell content.
+ *
+ * - `'left'` - Align content to the left
+ * - `'center'` - Center align content
+ * - `'right'` - Align content to the right
+ */
+type GridCellAlign = 'left' | 'center' | 'right';
+type GridTooltipContext<Data extends AnyDict = AnyDict> = {
+    $implicit: Data;
+    row: Data;
+    col: GridColumn<Data>;
+    index: number;
+    value: AnyType;
+};
+type GridColumnTooltip<Data extends AnyDict = AnyDict> = string | ((row: Data) => string) | TemplateRef<GridTooltipContext<AnyDict>>;
+/**
+ * Sticky column side.
+ *
+ * - `'left'` - Stick to the left edge
+ * - `'right'` - Stick to the right edge
+ */
+type GridStickySide = 'left' | 'right';
+/**
+ * Built-in cell renderer types for common data display formats.
+ *
+ * - `'plain'` - Display raw text value (default)
+ * - `'date'` - Format and display date values
+ * - `'number'` - Format and display numeric values
+ * - `'index'` - Display row index number
+ * - `'checkbox'` - Display checkbox for selection
+ */
+type GridCellRendererType = 'plain' | 'date' | 'number' | 'index' | 'checkbox';
+/**
+ * Array of column definitions for the data grid.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type GridColumns<Data extends AnyDict = AnyDict> = GridColumn<Data>[];
+/**
+ * Union type representing different column definition variants.
+ *
+ * A column can use built-in renderers, custom value functions, or Angular templates
+ * for rendering cell content.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type GridColumn<Data extends AnyDict = AnyDict> = _DefaultGridColumn<Data> | _ValuedGridColumn<Data> | _TemplatedGridColumn<Data>;
+/**
+ * Column definition using built-in cell renderer types.
+ *
+ * Extends the base column with an optional renderer type specification.
+ * If no type is specified, defaults to `'plain'` renderer.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type _DefaultGridColumn<Data extends AnyDict = AnyDict> = BaseGridColumn<Data> & {
+    /**
+     * Built-in renderer type for formatting cell values.
+     */
+    type?: GridCellRendererType;
+    /**
+     * Optional configuration or formatting options passed to the renderer (e.g., date/number format). *[NEW in 1.1.0]*
+     */
+    typeParams?: AnyType;
+    /**
+     * Fallback value used when the raw cell value is `null` or `undefined`.
+     */
+    defaultValue?: AnyType;
+};
+/**
+ * Column definition using a custom value renderer function.
+ *
+ * Allows custom logic for transforming row data into display values.
+ * Requires a tracking function for change detection optimization.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type _ValuedGridColumn<Data extends AnyDict = AnyDict> = BaseGridColumn<Data> & {
+    /**
+     * Function returning unique identifier for the row (for change detection).
+     */
+    track: (row: Data) => string;
+    /**
+     * Function that resolves cell display value from row data.
+     */
+    value: GridCellRenderer<Data>;
+};
+/**
+ * Column definition using an Angular template for cell rendering.
+ *
+ * Provides maximum flexibility by allowing custom HTML templates
+ * with full access to row data, column config, and cell context.
+ * Requires a tracking function for change detection optimization.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type _TemplatedGridColumn<Data extends AnyDict = AnyDict> = BaseGridColumn<Data> & {
+    /**
+     * Function returning unique identifier for the row (for change detection).
+     */
+    track: (row: Data) => string;
+    /**
+     * Angular TemplateRef for rendering cell content.
+     */
+    renderTemplate: TemplateRef<RenderTemplateData<Data>>;
+};
+/**
+ * Base properties shared by all column definition types.
+ *
+ * Contains configuration for column identification, header display,
+ * sizing, alignment, visibility, and behavior.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type BaseGridColumn<Data extends AnyDict = AnyDict> = {
+    /**
+     * Data property key this column displays.
+     */
+    key: DataKey<Data>;
+    /**
+     * Optional alternative key for sorting (if different from a display key).
+     */
+    sortKey?: string;
+    /**
+     * Column header text string.
+     */
+    header: string;
+    /**
+     * Optional Angular template for custom header rendering.
+     * If provided, overrides the default text header.
+     */
+    headerTemplate?: TemplateRef<HeaderTemplateData>;
+    /**
+     * Horizontal alignment of cell content.
+     */
+    align?: GridCellAlign;
+    /**
+     * CSS class(es) to apply to cells.
+     * Can be a static string or a resolver function that returns a class string based on row data.
+     */
+    cellClass?: KeyResolver<Data> | string;
+    /**
+     * Fixed column width in pixels.
+     */
+    width?: number;
+    /**
+     * Minimum column width in pixels.
+     */
+    minWidth?: number;
+    /**
+     * Maximum column width in pixels.
+     */
+    maxWidth?: number;
+    /**
+     * Flex grow factor for flexible width columns.
+     */
+    flex?: number;
+    /**
+     * Whether the column is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the column is visible.
+     */
+    visible?: boolean;
+    /**
+     * Whether the column remains fixed during the horizontal scroll.
+     *
+     * Use `'left'` or `'right'` to pin to the corresponding side.
+     * The `true` value is kept for backward compatibility and behaves as `'left'`.
+     */
+    sticky?: GridStickySide | true;
+    /**
+     * Optional tooltip content shown on cell hover.
+     */
+    tooltip?: GridColumnTooltip<Data>;
+    /**
+     * Data key to use for expanding/collapsing row details.
+     */
+    expandBy?: DataKey<Data>;
+};
+/**
+ * Type for custom cell value resolver functions.
+ *
+ * Function that takes row data and returns a string or number for display.
+ * Used in `_ValuedGridColumn` to customize how cell values are extracted and formatted.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type GridCellRenderer<Data> = KeyResolver<Data, string | number>;
+/**
+ * Context data provided to the header template.
+ *
+ * Implicit value is the header text string.
+ */
+type HeaderTemplateData = {
+    /**
+     * The column header text string.
+     */
+    $implicit: string;
+};
+/**
+ * Context data provided to cell render template.
+ *
+ * Provides comprehensive access to cell, row, and column information
+ * for use within custom Angular templates.
+ *
+ * @template Data - Type of data objects displayed in the grid rows
+ */
+type RenderTemplateData<Data extends AnyDict = AnyDict> = {
+    /**
+     * The cell's display value as string (implicit context).
+     */
+    $implicit: string;
+    /**
+     * The cell's display value as string (same as $implicit).
+     */
+    value: string;
+    /**
+     * Complete data object for the current row.
+     */
+    row: Data;
+    /**
+     * Column definition configuration object.
+     */
+    col: GridColumn<Data>;
+    /**
+     * Zero-based row index in the current data set.
+     */
+    index: number;
+};
+type DeclarativeColumnDef<Data extends AnyDict = AnyDict> = {
+    key: DataKey<Data>;
+    header?: string;
+    headerTemplate?: TemplateRef<HeaderTemplateData>;
+    cellTemplate?: TemplateRef<AnyType>;
+    align?: GridCellAlign;
+    sortKey?: string;
+    sticky?: GridStickySide | true;
+    expandBy?: DataKey<Data>;
+    disabled?: boolean;
+    visible?: boolean;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    type?: GridCellRendererType;
+    typeParams?: AnyType;
+    defaultValue?: AnyType;
+    value?: GridCellRenderer<Data>;
+    track?: (row: Data) => string;
+    tooltip?: GridColumnTooltip<Data>;
+};
+
+type DataGridRowTemplateContext<Data extends AnyDict> = {
+    $implicit: Data;
+    index: number;
+    columns: GridColumn<Data>[];
+    rowHeight: number;
+    isSticky: boolean;
+};
+/**
+ * Directive for providing a custom template for data grid rows.
+ *
+ * Used as a structural directive on `<ng-template>` elements within data grid components.
+ * The template receives row data, index, columns, and layout helpers.
+ *
+ * Example:
+ * ```html
+ * <ng-template reDataGridRow let-row let-index="index">
+ *   <div class="my-row">{{ index + 1 }} - {{ row.name }}</div>
+ * </ng-template>
+ * ```
+ *
+ * Template context:
+ * - `$implicit: Data` — row data
+ * - `index: number` — row index
+ * - `columns: GridColumn<Data>[]` — visible columns
+ * - `rowHeight: number` — row height in pixels
+ * - `isSticky: boolean` — sticky row flag
+ */
+declare class DataGridRowDirective<Data extends AnyDict> {
+    tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridRowDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridRowDirective<any>, "ng-template[reDataGridRow]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DataGridDeclarativeColumn<Data extends AnyDict = AnyDict> {
+    key: _angular_core.InputSignal<DataKey<Data>>;
+    header: _angular_core.InputSignal<string | undefined>;
+    align: _angular_core.InputSignal<GridCellAlign | undefined>;
+    sortKey: _angular_core.InputSignal<string | undefined>;
+    sticky: _angular_core.InputSignal<true | GridStickySide | undefined>;
+    expandBy: _angular_core.InputSignal<DataKey<Data> | undefined>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, string | boolean | undefined>;
+    visible: _angular_core.InputSignalWithTransform<boolean, string | boolean | undefined>;
+    width: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    minWidth: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    maxWidth: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    flex: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    type: _angular_core.InputSignal<GridCellRendererType | undefined>;
+    typeParams: _angular_core.InputSignal<any>;
+    defaultValue: _angular_core.InputSignal<any>;
+    value: _angular_core.InputSignal<GridCellRenderer<Data> | undefined>;
+    track: _angular_core.InputSignal<((row: Data) => string) | undefined>;
+    tooltip: _angular_core.InputSignal<GridColumnTooltip<Data> | undefined>;
+    private headerTplRef;
+    private cellTplRef;
+    toDeclarativeColumn(): DeclarativeColumnDef<Data>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridDeclarativeColumn<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataGridDeclarativeColumn<any>, "re-dg-column", never, { "key": { "alias": "key"; "required": true; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sortKey": { "alias": "sortKey"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "expandBy": { "alias": "expandBy"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "flex": { "alias": "flex"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "typeParams": { "alias": "typeParams"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "track": { "alias": "track"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; }, {}, ["headerTplRef", "cellTplRef"], ["*"], true, never>;
+}
+
+declare class DataGridDeclarativeHeaderDirective {
+    tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridDeclarativeHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridDeclarativeHeaderDirective, "ng-template[reHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class DataGridDeclarativeCellDirective {
+    tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridDeclarativeCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridDeclarativeCellDirective, "ng-template[reCell]", never, {}, {}, never, never, true, never>;
+}
+
 /**
  * Directive for providing a custom template to display when the data grid has no data.
  *
@@ -124,6 +475,33 @@ declare class DataGridCellLoadingDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridCellLoadingDirective, "ng-template[reDataGridLoading]", never, {}, {}, never, never, true, never>;
 }
 
+type DataGridStickyRowTemplateContext<Data> = {
+    $implicit: Data;
+    index: number;
+};
+/**
+ * Directive for providing a custom template for sticky rows.
+ *
+ * Used as a structural directive on `<ng-template>` elements within data grid components.
+ * The template receives row data and its index.
+ *
+ * Example:
+ * ```html
+ * <ng-template reDataGridStickyRow let-row let-index="index">
+ *   <div class="my-sticky-row">{{ index }} - {{ row.name }}</div>
+ * </ng-template>
+ * ```
+ *
+ * Template context:
+ * - `$implicit: Data` — row data
+ * - `index: number` — row index
+ */
+declare class DataGridStickyRowDirective<Data> {
+    tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridStickyRowDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridStickyRowDirective<any>, "ng-template[reDataGridStickyRow]", never, {}, {}, never, never, true, never>;
+}
+
 declare class DataGridSortIconDirective {
     tpl: TemplateRef<any>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridSortIconDirective, never>;
@@ -135,43 +513,6 @@ declare class DataGridExpanderIconDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DataGridExpanderIconDirective, "ng-template[reDataGridExpanderIcon]", never, {}, {}, never, never, true, never>;
 }
 
-declare class DataGridPaginator {
-    current: _angular_core.InputSignalWithTransform<number, string | number | undefined>;
-    totalElements: _angular_core.InputSignalWithTransform<number, string | number | undefined>;
-    pageSize: _angular_core.InputSignalWithTransform<number, string | number | undefined>;
-    maxShowPages: _angular_core.InputSignalWithTransform<number, string | number | undefined>;
-    pageChange: _angular_core.OutputEmitterRef<number>;
-    totalPages: _angular_core.Signal<number>;
-    pages: _angular_core.Signal<number[]>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridPaginator, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataGridPaginator, "re-data-grid-paginator", never, { "current": { "alias": "current"; "required": false; "isSignal": true; }; "totalElements": { "alias": "totalElements"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "maxShowPages": { "alias": "maxShowPages"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
-}
-
-/**
- * Represents a key of an object that is also a string, or any string.
- * Used for identifying data properties in rows.
- */
-type DataKey<Data> = (keyof Data & string) | string;
-/**
- * Function type that resolves a value of type `Return` from an argument of type `Arg`.
- * Often used to transform row data or extract specific properties.
- */
-type KeyResolver<Arg = AnyType, Return = string> = (arg: Arg) => Return;
-/**
- * Union type for row identification.
- * Can be either a property key (string) or a resolver function.
- */
-type RowKeyFn<Data> = DataKey<Data> | KeyResolver<Data, string | number>;
-/**
- * Type alias for `any`.
- */
-type AnyType = any;
-/**
- * Represents an object with string keys and values of any type.
- * Common base type for row data.
- */
-type AnyDict = Record<string, AnyType>;
-
 /**
  * Defines how pagination is displayed and handled in the data grid.
  *
@@ -188,44 +529,20 @@ type GridPaginationMode = 'none' | 'pagination' | 'infinity';
  */
 type GridPinnedPosition = 'top' | 'bottom';
 /**
- * Row selection mode for the data grid.
- *
- * - `'single'` - Allow selecting only one row at a time
- * - `'multi'` - Allow selecting multiple rows
- * - `'none'` - Disable row selection
- */
-type GridSelectMode = 'single' | 'multi' | 'none';
-/**
- * Sort direction for grid columns.
- *
- * - `'asc'` - Ascending order (A to Z, 0 to 9)
- * - `'desc'` - Descending order (Z to A, 9 to 0)
- */
-type GridSortOrder = 'asc' | 'desc';
-/**
- * Horizontal alignment options for grid cell content.
- *
- * - `'left'` - Align content to the left
- * - `'center'` - Center align content
- * - `'right'` - Align content to the right
- */
-type GridCellAlign = 'left' | 'center' | 'right';
-/**
- * Built-in cell renderer types for common data display formats.
+ * Row selection mode for the data grid.
  *
- * - `'plain'` - Display raw text value (default)
- * - `'date'` - Format and display date values
- * - `'number'` - Format and display numeric values
- * - `'index'` - Display row index number
- * - `'checkbox'` - Display checkbox for selection
+ * - `'single'` - Allow selecting only one row at a time
+ * - `'multi'` - Allow selecting multiple rows
+ * - `'none'` - Disable row selection
  */
-type GridCellRendererType = 'plain' | 'date' | 'number' | 'index' | 'checkbox';
+type GridSelectMode = 'single' | 'multi' | 'none';
 /**
- * Array of column definitions for the data grid.
+ * Sort direction for grid columns.
  *
- * @template Data - Type of data objects displayed in the grid rows
+ * - `'asc'` - Ascending order (A to Z, 0 to 9)
+ * - `'desc'` - Descending order (Z to A, 9 to 0)
  */
-type GridColumns<Data extends AnyDict = AnyDict> = GridColumn<Data>[];
+type GridSortOrder = 'asc' | 'desc';
 /**
  * Array of pinned row definitions for the data grid.
  *
@@ -301,187 +618,62 @@ type GridPinnedRow<Data extends AnyDict = AnyDict> = {
         $implicit: Partial<Data>;
     }>;
 };
-/**
- * Union type representing different column definition variants.
- *
- * A column can use built-in renderers, custom value functions, or Angular templates
- * for rendering cell content.
- *
- * @template Data - Type of data objects displayed in the grid rows
- */
-type GridColumn<Data extends AnyDict = AnyDict> = _DefaultGridColumn<Data> | _ValuedGridColumn<Data> | _TemplatedGridColumn<Data>;
-/**
- * Base properties shared by all column definition types.
- *
- * Contains configuration for column identification, header display,
- * sizing, alignment, visibility, and behavior.
- *
- * @template Data - Type of data objects displayed in the grid rows
- */
-type _BaseGridColumn<Data extends AnyDict = AnyDict> = {
-    /**
-     * Data property key this column displays.
-     */
-    key: DataKey<Data>;
-    /**
-     * Optional alternative key for sorting (if different from a display key).
-     */
-    sortKey?: string;
-    /**
-     * Column header text string.
-     */
-    header: string;
-    /**
-     * Optional Angular template for custom header rendering.
-     * If provided, overrides the default text header.
-     */
-    headerTemplate?: TemplateRef<HeaderTemplateData>;
-    /**
-     * Horizontal alignment of cell content.
-     */
-    align?: GridCellAlign;
-    /**
-     * CSS class(es) to apply to cells.
-     * Can be a static string or a resolver function that returns a class string based on row data.
-     */
-    cellClass?: KeyResolver<Data> | string;
-    /**
-     * Fixed column width in pixels.
-     */
-    width?: number;
-    /**
-     * Minimum column width in pixels.
-     */
-    minWidth?: number;
-    /**
-     * Maximum column width in pixels.
-     */
-    maxWidth?: number;
-    /**
-     * Flex grow factor for flexible width columns.
-     */
-    flex?: number;
-    /**
-     * Whether the column is disabled.
-     */
-    disabled?: boolean;
-    /**
-     * Whether the column is visible.
-     */
-    visible?: boolean;
-    /**
-     * Whether the column remains fixed during the horizontal scroll.
-     */
-    sticky?: boolean;
-    /**
-     * Data key to use for expanding/collapsing row details.
-     */
-    expandBy?: DataKey<Data>;
-};
-/**
- * Column definition using built-in cell renderer types.
- *
- * Extends the base column with an optional renderer type specification.
- * If no type is specified, defaults to `'plain'` renderer.
- *
- * @template Data - Type of data objects displayed in the grid rows
- */
-type _DefaultGridColumn<Data extends AnyDict = AnyDict> = _BaseGridColumn<Data> & {
-    /**
-     * Built-in renderer type for formatting cell values.
-     */
-    type?: GridCellRendererType;
-    /**
-     * Optional configuration or formatting options passed to the renderer (e.g., date/number format). *[NEW in 1.1.0]*
-     */
-    typeParams?: AnyType;
-};
-/**
- * Column definition using a custom value renderer function.
- *
- * Allows custom logic for transforming row data into display values.
- * Requires a tracking function for change detection optimization.
- *
- * @template Data - Type of data objects displayed in the grid rows
- */
-type _ValuedGridColumn<Data extends AnyDict = AnyDict> = _BaseGridColumn<Data> & {
-    /**
-     * Function returning unique identifier for the row (for change detection).
-     */
-    track: (row: Data) => string;
-    /**
-     * Function that resolves cell display value from row data.
-     */
-    value: GridCellRenderer<Data>;
-};
-/**
- * Column definition using an Angular template for cell rendering.
- *
- * Provides maximum flexibility by allowing custom HTML templates
- * with full access to row data, column config, and cell context.
- * Requires a tracking function for change detection optimization.
- *
- * @template Data - Type of data objects displayed in the grid rows
- */
-type _TemplatedGridColumn<Data extends AnyDict = AnyDict> = _BaseGridColumn<Data> & {
-    /**
-     * Function returning unique identifier for the row (for change detection).
-     */
-    track: (row: Data) => string;
-    /**
-     * Angular TemplateRef for rendering cell content.
-     */
-    renderTemplate: TemplateRef<RenderTemplateData<Data>>;
+
+type DataGridTranslations = {
+    emptyState: string;
+    itemsPerPageLabel: string;
+    nextPageLabel: string;
+    prevPageLabel: string;
 };
 /**
- * Type for custom cell value resolver functions.
- *
- * Function that takes row data and returns a string or number for display.
- * Used in `_ValuedGridColumn` to customize how cell values are extracted and formatted.
- *
- * @template Data - Type of data objects displayed in the grid rows
- */
-type GridCellRenderer<Data> = KeyResolver<Data, string | number>;
-/**
- * Context data provided to the header template.
+ * Global default configuration for all `re-data-grid` instances.
  *
- * Implicit value is the header text string.
+ * Use this shape in `provideDataGridDefaults(...)` to override base behavior
+ * (pagination mode, row sizes, buffering, labels, debounce timings, etc.)
+ * application-wide or within a scoped injector.
  */
-type HeaderTemplateData = {
-    /**
-     * The column header text string.
-     */
-    $implicit: string;
+type DataGridConfigProvider = {
+    /** Pagination mode for the data grid. */
+    mode: GridPaginationMode;
+    /** Whether to display an index column with row numbers. */
+    hasIndexColumn: boolean;
+    /** Row selection configuration, including selection mode and behavior. */
+    selection: GridSelection;
+    /** Number of items to display per page. */
+    pageSize: number;
+    /** Height of each data row in pixels. */
+    rowHeight: number;
+    /** Height of the header row in pixels. */
+    headerHeight: number;
+    /** Grid height: a number in pixels, 'full' for 100% height, or 'default' for auto-calculated height. */
+    height: number | 'full' | 'default';
+    /** Number of extra rows to render above and below the visible viewport for smoother scrolling. */
+    virtualBuffer: number;
+    /** Loading indicator style: 'spinner' shows a loading spinner, 'skeleton' shows skeleton placeholders. */
+    loadingMode: 'spinner' | 'skeleton';
+    /** Whether pagination starts from page 0 (true) or page 1 (false). */
+    pageStartFromZero: boolean;
+    /** Text strings for UI labels and messages. */
+    translations: DataGridTranslations;
+    /** Debounce timings in milliseconds for resize and scroll events to optimize performance. */
+    debounce: {
+        resize: number;
+        scroll: number;
+    };
 };
+declare const DEFAULT_DATA_GRID_DEFAULTS: DataGridConfigProvider;
+declare const DATA_GRID_CONFIG: InjectionToken<DataGridConfigProvider>;
 /**
- * Context data provided to cell render template.
- *
- * Provides comprehensive access to cell, row, and column information
- * for use within custom Angular templates.
+ * Provides default configuration for Data Grid, overriding base settings.
  *
- * @template Data - Type of data objects displayed in the grid rows
+ * @param config Partial configuration object to be merged with current settings.
+ * @returns EnvironmentProviders for use in application or component configuration.
  */
-type RenderTemplateData<Data extends AnyDict = AnyDict> = {
-    /**
-     * The cell's display value as string (implicit context).
-     */
-    $implicit: string;
-    /**
-     * The cell's display value as string (same as $implicit).
-     */
-    value: string;
-    /**
-     * Complete data object for the current row.
-     */
-    row: Data;
-    /**
-     * Column definition configuration object.
-     */
-    col: GridColumn<Data>;
-    /**
-     * Zero-based row index in the current data set.
-     */
-    index: number;
+declare function provideDataGridDefaults(config: Partial<DataGridConfigProvider>): EnvironmentProviders;
+
+type DeclarativeColumnsResult<Data extends AnyDict = AnyDict> = {
+    columns: GridColumns<Data>;
+    rowCellTemplatesByKey: Map<string, TemplateRef<AnyType>>;
 };
 
 /**
@@ -533,6 +725,7 @@ type GridSelectEvent<Data extends AnyDict = AnyDict> = {
 type GridRowClickEvent<Data extends AnyDict = AnyDict> = {
     row: Data;
     index: number;
+    event: Event;
 };
 /**
  * Event emitted when a specific cell is clicked in the data grid.
@@ -546,6 +739,97 @@ type GridCellClickEvent<Data extends AnyDict = AnyDict> = {
     row: Data;
     col: GridColumn<Data>;
     index: number;
+    event: Event;
+};
+/**
+ * Event emitted when a row is right-clicked (context menu) in the data grid.
+ *
+ * Provides access to the clicked row's data object, its index, and the native mouse event.
+ */
+type GridRowContextEvent<Data extends AnyDict = AnyDict> = {
+    row: Data;
+    index: number;
+    event: MouseEvent;
+};
+/**
+ * Event emitted when a specific cell is right-clicked (context menu) in the data grid.
+ *
+ * Provides access to the clicked cell, row data, index, and the native mouse event.
+ */
+type GridCellContextEvent<Data extends AnyDict = AnyDict> = {
+    row: Data;
+    col: GridColumn<Data>;
+    index: number;
+    event: MouseEvent;
+};
+/**
+ * Event emitted when a row is double-clicked in the data grid.
+ *
+ * Provides access to the clicked row's data object, its index, and the native mouse event.
+ */
+type GridRowDoubleClickEvent<Data extends AnyDict = AnyDict> = {
+    row: Data;
+    index: number;
+    event: MouseEvent;
+};
+/**
+ * Event emitted when a specific cell is double-clicked in the data grid.
+ *
+ * Provides access to the clicked cell, row data, index, and the native mouse event.
+ */
+type GridCellDoubleClickEvent<Data extends AnyDict = AnyDict> = {
+    row: Data;
+    col: GridColumn<Data>;
+    index: number;
+    event: MouseEvent;
+};
+
+type TemplatedHeader = {
+    titleTemplate: TemplateRef<HeaderTemplateData>;
+};
+type PlainHeader = {
+    title: string;
+    align?: GridCellAlign;
+};
+/**
+ * Defines a header group configuration for grouping multiple columns under a single header.
+ *
+ * @template Data - The data type of the grid rows
+ *
+ * @property {string} key - Unique identifier for the header group
+ * @property {DataKey<Data>} from - The starting column key where the header group begins
+ * @property {DataKey<Data>} [to] - Optional ending column key where the header group ends.
+ *  If not provided, the group spans only the 'from' column
+ * @property {string} [title] - Plain text title for the header group (when using PlainHeader)
+ * @property {GridCellAlign} [align] - Text alignment for the header group title (when using PlainHeader)
+ * @property {TemplateRef<HeaderTemplateData>} [titleTemplate] - Custom template for rendering the header group title
+ *  (when using TemplatedHeader)
+ */
+type GridHeaderGroup<Data extends AnyDict = AnyDict> = {
+    key: string;
+    from: DataKey<Data>;
+    to?: DataKey<Data>;
+} & (TemplatedHeader | PlainHeader);
+/**
+ * Internal normalized representation of a header group after processing.
+ * Used by the grid component to render header groups with calculated dimensions.
+ *
+ * @property {string} key - Unique identifier for the normalized header
+ * @property {string} [title] - Plain text title for the header
+ * @property {TemplateRef<HeaderTemplateData>} [titleTemplate] - Custom template for rendering the header title
+ * @property {GridCellAlign} [align] - Text alignment for the header title
+ * @property {number} widthPx - Calculated width of the header in pixels
+ * @property {string} [startKey] - Column key where the header group starts
+ * @property {string} [endKey] - Column key where the header group ends
+ */
+type NormalizedHeader = {
+    key: string;
+    title?: string;
+    titleTemplate?: TemplateRef<HeaderTemplateData>;
+    align?: GridCellAlign;
+    widthPx: number;
+    startKey?: string;
+    endKey?: string;
 };
 
 /**
@@ -586,6 +870,7 @@ declare class DataGridVm<Data extends AnyDict> {
      * Each row includes data, position ('top' or 'bottom'), and optional ordering.
      */
     pinnedRows: _angular_core.WritableSignal<GridPinnedRow<Data>[]>;
+    headerGroups: _angular_core.WritableSignal<GridHeaderGroup<Data>[]>;
     /**
      * Current width of the grid container in pixels.
      *
@@ -625,6 +910,9 @@ declare class DataGridVm<Data extends AnyDict> {
      */
     globalTypeCellTpls: Map<GridCellRendererType, TemplateRef<Data>>;
     globalDataCellTpls: Map<string | keyof Data, TemplateRef<Data>>;
+    globalRowCellTpls: Map<string | keyof Data, TemplateRef<Data>>;
+    pinnedTop: _angular_core.WritableSignal<GridPinnedRow<Data>[]>;
+    pinnedBottom: _angular_core.WritableSignal<GridPinnedRow<Data>[]>;
     /**
      * Computed an array of non-sticky columns to display in the scrollable area.
      *
@@ -633,20 +921,18 @@ declare class DataGridVm<Data extends AnyDict> {
      * Recalculates whenever columns or container width changes.
      */
     columnsToShow: _angular_core.Signal<GridColumn<Data>[]>;
+    contentWidth: _angular_core.Signal<number>;
     /**
-     * Computed array of rows pinned to the top of the grid.
+     * Computed array of normalized header groups with calculated widths.
      *
-     * Filters pinned rows by 'top' position and sorts them by order property.
-     * Rows with lower order values appear first.
-     */
-    pinnedTop: _angular_core.Signal<GridPinnedRow<Data>[]>;
-    /**
-     * Computed array of rows pinned to the bottom of the grid.
+     * Transforms raw header group configurations into normalized structures
+     * that include computed column widths for layout rendering. Returns an empty
+     * array if no headers or columns are configured. Recalculates whenever
+     * header groups or visible columns change.
      *
-     * Filters pinned rows by 'bottom' position and sorts them by order property.
-     * Rows with lower order values appear first.
+     * @returns Array of normalized header configurations with width calculations
      */
-    pinnedBottom: _angular_core.Signal<GridPinnedRow<Data>[]>;
+    normalizedHeaderGroups: _angular_core.Signal<NormalizedHeader[]>;
     constructor();
     /**
      * Returns the computed width for a column by its key.
@@ -744,14 +1030,14 @@ declare class Selector<Data extends AnyDict> {
      * - `false` if no rows are selected
      * - `'mixed'` if some but not all rows are selected
      *
-     * Useful for implementing "select all" checkbox with indeterminate state.
+     * Useful for implementing the "select all" checkbox with an indeterminate state.
      */
     isAllSelected: _angular_core.Signal<boolean | "mixed">;
     /**
      * Checks whether a specific row is currently selected.
      *
      * Compares the row's key value against the list of selected keys.
-     * Returns `false` if selection mode is 'none' or key is not configured.
+     * Returns `false` if the selection mode is 'none' or the key is not configured.
      *
      * @param row - The data row to check selection status for.
      * @returns `true` if the row is selected, `false` otherwise.
@@ -785,6 +1071,14 @@ declare class Selector<Data extends AnyDict> {
     select(row: Data): (string | Data[DataKey<Data>])[];
 }
 
+type TooltipState = {
+    text?: string;
+    tpl?: TemplateRef<GridTooltipContext<AnyDict>>;
+    ctx?: GridTooltipContext<AnyDict>;
+    x: number;
+    y: number;
+    visible: boolean;
+};
 /**
  * Data grid component with virtual scrolling, sorting, selection, and pagination support.
  *
@@ -807,6 +1101,7 @@ declare class Selector<Data extends AnyDict> {
  * ```
  */
 declare class DataGrid<Data extends AnyDict> {
+    protected defaults: _reforgium_data_grid.DataGridConfigProvider;
     /**
      * Array of data to display in the table.
      *
@@ -820,7 +1115,7 @@ declare class DataGrid<Data extends AnyDict> {
      * Defines how each column should be rendered, sorted, and styled.
      * Supports custom templates, sorting keys, and expandable columns.
      */
-    columns: _angular_core.InputSignal<GridColumn<Data>[]>;
+    columns: _angular_core.InputSignal<GridColumns<Data>>;
     /**
      * Pagination mode: 'none', 'pagination', or 'infinity'.
      *
@@ -836,12 +1131,26 @@ declare class DataGrid<Data extends AnyDict> {
      * Useful for totals, summaries, or always-visible items.
      */
     pinnedRows: _angular_core.InputSignal<GridPinnedRow<Data>[]>;
+    /**
+     * Function to determine if a row should become sticky at the top.
+     *
+     * When provided, rows matching this predicate will stick to the top
+     * of the scroll area as the user scrolls.
+     */
+    isRowSticky: _angular_core.InputSignal<((row: Data, index: number) => boolean) | undefined>;
+    /**
+     * Function to choose a custom template for a row.
+     *
+     * If it returns a template, the row will be rendered with it;
+     *  otherwise, the default row rendering is used.
+     */
+    getRowTemplate: _angular_core.InputSignal<((row: Data, index: number) => TemplateRef<Data> | undefined | null) | undefined>;
     /**
      * Whether to add an index column showing row numbers.
      *
      * When enabled, it automatically adds a column displaying sequential row numbers.
      */
-    hasIndexColumn: _angular_core.InputSignalWithTransform<boolean, string | number | undefined>;
+    hasIndexColumn: _angular_core.InputSignalWithTransform<boolean, string | boolean | undefined>;
     /**
      * Row selection configuration.
      *
@@ -879,9 +1188,29 @@ declare class DataGrid<Data extends AnyDict> {
      * Size of the virtual scroll buffer.
      *
      * Number of extra rows to render above and below the viewport
-     * to reduce flickering during fast scrolling. Default is 6.
+     * to reduce flickering during fast scrolling. Default is 8.
      */
     virtualBuffer: _angular_core.InputSignal<number>;
+    /**
+     * Header group configuration for creating multi-level column headers.
+     *
+     * Allows grouping multiple columns under a common header label.
+     * Each group spans from a starting column to an ending column and can have a custom alignment.
+     *
+     * @example
+     * ```typescript
+     * headerGroups = [
+     *   {
+     *     key: 'personal-info',
+     *     title: 'Personal Information',
+     *     from: 'name',
+     *     to: 'email',
+     *     align: 'center'
+     *   }
+     * ];
+     * ```
+     */
+    headerGroups: _angular_core.InputSignal<GridHeaderGroup<Data>[]>;
     /**
      * Loading state indicator.
      *
@@ -889,8 +1218,9 @@ declare class DataGrid<Data extends AnyDict> {
      * Useful during async data fetching operations.
      */
     loading: _angular_core.InputSignalWithTransform<boolean, string | boolean | undefined>;
+    loadingMode: _angular_core.InputSignal<"spinner" | "skeleton">;
     /**
-     * Function or property name for obtaining a unique row key.
+     * Function or property name for getting a unique row key.
      *
      * Used for efficient change detection and row tracking.
      * Can be a property name (string) or a function that returns a unique identifier.
@@ -944,42 +1274,89 @@ declare class DataGrid<Data extends AnyDict> {
      * Contains the clicked row data and its index.
      */
     rowClick: _angular_core.OutputEmitterRef<GridRowClickEvent<Data>>;
+    /**
+     * Event emitted when a row is right-clicked (context menu).
+     *
+     * Contains the clicked row data, its index, and the native mouse event.
+     */
+    rowContext: _angular_core.OutputEmitterRef<GridRowContextEvent<Data>>;
+    /**
+     * Event emitted when a row is double-clicked.
+     *
+     * Contains the clicked row data, its index, and the native mouse event.
+     */
+    rowDoubleClick: _angular_core.OutputEmitterRef<GridRowDoubleClickEvent<Data>>;
     /**
      * Event emitted when a cell is clicked.
      *
      * Contains the clicked row, column configuration, and row index.
      */
     cellClick: _angular_core.OutputEmitterRef<GridCellClickEvent<Data>>;
+    /**
+     * Event emitted when a cell is right-clicked (context menu).
+     *
+     * Contains the clicked row, column configuration, row index, and the native mouse event.
+     */
+    cellContext: _angular_core.OutputEmitterRef<GridCellContextEvent<Data>>;
+    /**
+     * Event emitted when a cell is double-clicked.
+     *
+     * Contains the clicked row, column configuration, row index, and the native mouse event.
+     */
+    cellDoubleClick: _angular_core.OutputEmitterRef<GridCellDoubleClickEvent<Data>>;
     vm: DataGridVm<Data>;
     selector: Selector<Data>;
     private rootEl;
     private scrollEl;
     private headerEl;
+    private ngZone;
     private cellTypedSlotRefs;
     private cellDataSlotRefs;
+    private declarativeColumnRefs;
     private headerSlotRefs;
     private emptySlotRefs;
     private loadingSlotRefs;
     private sortIcSlotRefs;
     private expanderIcSlotRefs;
-    protected emptyTpl: _angular_core.Signal<DataGridCellEmptyDirective>;
+    private stickyRowSlotRefs;
+    private rowSlotRefs;
+    protected emptyTpl: _angular_core.Signal<DataGridCellEmptyDirective | undefined>;
     protected loadingTpl: _angular_core.Signal<DataGridCellLoadingDirective>;
     protected sortTpl: _angular_core.Signal<DataGridSortIconDirective | undefined>;
     protected expanderTpl: _angular_core.Signal<DataGridExpanderIconDirective | undefined>;
-    protected visibleRows: _angular_core.WritableSignal<Data[]>;
+    protected stickyRowTpl: _angular_core.Signal<DataGridStickyRowDirective<any> | undefined>;
+    protected rowTpl: _angular_core.Signal<DataGridRowDirective<any> | undefined>;
+    protected renderSlots: _angular_core.WritableSignal<number[]>;
+    protected renderCount: number;
+    private lastStartIndex;
+    private lastEndIndex;
     protected startIndex: number;
     protected headerHeight: _angular_core.WritableSignal<number>;
+    protected stickyRowIndex: _angular_core.WritableSignal<number | null>;
+    protected stickyRowTopPx: _angular_core.WritableSignal<number>;
+    protected stickyRowData: _angular_core.Signal<Data | null>;
+    private stickyIndexes;
     protected expanderMap: _angular_core.WritableSignal<Map<DataKey<Data>, boolean>>;
+    protected declarativeColumns: _angular_core.Signal<DeclarativeColumnsResult<Data>>;
+    protected sourceColumns: _angular_core.Signal<GridColumn<Data>[]>;
     protected extendedColumns: _angular_core.Signal<GridColumn<Data>[]>;
     /**
      * Computed CSS height value based on height setting.
      */
     styleHeight: _angular_core.Signal<string>;
     private hideSbTimeout?;
+    private scrollRafId;
+    private scrollbarRafId;
+    private stickyRafId;
+    private lastInfinityPageRequested;
+    private lastInfinityTotal;
     currentSortField?: string;
     currentSortOrder: GridSortOrder;
     private subscription;
     private observer;
+    private resizeSubject;
+    private lastResizeWidth;
+    private lastResizeHeight;
     constructor();
     protected resolvePinnedData(pr: GridPinnedRow): Partial<Data>;
     /**
@@ -1001,8 +1378,11 @@ declare class DataGrid<Data extends AnyDict> {
      * @param row - Data row that was clicked
      * @param col - Column configuration of the clicked cell
      * @param index - Row index in the dataset
+     * @param event
      */
-    protected onCellClick(row: Data, col: GridColumn<Data>, index: number): void;
+    protected onCellClick(row: Data, col: GridColumn<Data>, index: number, event: Event): void;
+    protected onCellContext(row: Data, col: GridColumn<Data>, index: number, event: MouseEvent): void;
+    protected onCellDoubleClick(row: Data, col: GridColumn<Data>, index: number, event: MouseEvent): void;
     protected isExpandable(column: GridColumn<Data>): boolean;
     /**
      * Handles column expand/collapse toggle.
@@ -1037,9 +1417,16 @@ declare class DataGrid<Data extends AnyDict> {
     protected showScrollbar(): void;
     protected hideScrollbarSoon(delay?: number): void;
     protected trackPinnedRow: (row: GridPinnedRow) => number | undefined;
-    protected trackByRow: (row: Data) => string | number | Data | Data[DataKey<Data>];
     protected cellClass(col: GridColumn<Data>, row: Data): string | undefined;
     protected ariaSort(col: GridColumn<Data>): 'ascending' | 'descending' | 'none';
+    private tooltipEl;
+    protected tooltipState: _angular_core.WritableSignal<TooltipState>;
+    protected resolveTooltip(row: Data, col: GridColumn<Data>): string | TemplateRef<GridTooltipContext<AnyDict>> | null;
+    protected showTooltip(event: MouseEvent, row: Data, col: GridColumn<Data>, index: number): void;
+    protected hideTooltip(): void;
+    private positionTooltip;
+    protected isStickyRowIndex(index: number): boolean;
+    protected resolveRowTemplate(row: Data, index: number): TemplateRef<AnyType> | null;
     private initVm;
     private initSelector;
     private initRefs;
@@ -1048,10 +1435,20 @@ declare class DataGrid<Data extends AnyDict> {
     private initScroll;
     private initObserver;
     private initExpander;
+    private scheduleScrollbarUpdate;
+    private scheduleScrollTick;
+    private clearScrollRaf;
+    private ensureRenderSlots;
+    private clearScrollbarRaf;
+    private scheduleStickyUpdate;
+    private clearStickyRaf;
+    private updateStickyRow;
+    private updateStickyFromScroll;
+    private findStickyIndexBefore;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGrid<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataGrid<any>, "re-data-grid", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "pinnedRows": { "alias": "pinnedRows"; "required": false; "isSignal": true; }; "hasIndexColumn": { "alias": "hasIndexColumn"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "virtualBuffer": { "alias": "virtualBuffer"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "pageStartFromZero": { "alias": "pageStartFromZero"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "sortChange": "sortChange"; "selectChange": "selectChange"; "rowClick": "rowClick"; "cellClick": "cellClick"; }, ["cellTypedSlotRefs", "cellDataSlotRefs", "headerSlotRefs", "emptySlotRefs", "loadingSlotRefs", "sortIcSlotRefs", "expanderIcSlotRefs"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataGrid<any>, "re-data-grid", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "pinnedRows": { "alias": "pinnedRows"; "required": false; "isSignal": true; }; "isRowSticky": { "alias": "isRowSticky"; "required": false; "isSignal": true; }; "getRowTemplate": { "alias": "getRowTemplate"; "required": false; "isSignal": true; }; "hasIndexColumn": { "alias": "hasIndexColumn"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "virtualBuffer": { "alias": "virtualBuffer"; "required": false; "isSignal": true; }; "headerGroups": { "alias": "headerGroups"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMode": { "alias": "loadingMode"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "pageStartFromZero": { "alias": "pageStartFromZero"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "sortChange": "sortChange"; "selectChange": "selectChange"; "rowClick": "rowClick"; "rowContext": "rowContext"; "rowDoubleClick": "rowDoubleClick"; "cellClick": "cellClick"; "cellContext": "cellContext"; "cellDoubleClick": "cellDoubleClick"; }, ["cellTypedSlotRefs", "cellDataSlotRefs", "declarativeColumnRefs", "headerSlotRefs", "emptySlotRefs", "loadingSlotRefs", "sortIcSlotRefs", "expanderIcSlotRefs", "stickyRowSlotRefs", "rowSlotRefs"], never, true, never>;
 }
 
-export { DataGrid, DataGridCellEmptyDirective, DataGridCellLoadingDirective, DataGridCellTemplateDirective, DataGridExpanderIconDirective, DataGridHeaderTemplateDirective, DataGridPaginator, DataGridSortIconDirective, DataGridTypeCellTemplateDirective };
-export type { GridCellClickEvent, GridCellRenderer, GridColumn, GridColumns, GridPageChangeEvent, GridPinnedRow, GridPinnedRows, GridRowClickEvent, GridSelectEvent, GridSelection, GridSortEvent };
+export { DATA_GRID_CONFIG, DEFAULT_DATA_GRID_DEFAULTS, DataGrid, DataGridCellEmptyDirective, DataGridCellLoadingDirective, DataGridCellTemplateDirective, DataGridDeclarativeCellDirective, DataGridDeclarativeColumn, DataGridDeclarativeHeaderDirective, DataGridExpanderIconDirective, DataGridHeaderTemplateDirective, DataGridRowDirective, DataGridSortIconDirective, DataGridStickyRowDirective, DataGridTypeCellTemplateDirective, provideDataGridDefaults };
+export type { DataGridConfigProvider, DataGridRowTemplateContext, DataGridStickyRowTemplateContext, DeclarativeColumnDef, GridCellClickEvent, GridCellContextEvent, GridCellDoubleClickEvent, GridCellRenderer, GridColumn, GridColumns, GridHeaderGroup, GridPageChangeEvent, GridPinnedRow, GridPinnedRows, GridRowClickEvent, GridRowContextEvent, GridRowDoubleClickEvent, GridSelectEvent, GridSelection, GridSortEvent, RenderTemplateData };
 //# sourceMappingURL=reforgium-data-grid.d.ts.map