@geovi/the-datagrid 0.0.9 → 0.0.10

package/dist/types.d.ts

@@ -42,10 +42,22 @@ export type TypeSingleSortInfo = {
     name: string;
     id?: string;
     type?: string;
-    fn?: (...args: unknown[]) => unknown;
+    fn?: (value1: unknown, value2: unknown, data1: unknown, data2: unknown, sortInfo: TypeSingleSortInfo) => number | boolean;
     columnName?: string;
 };
 export type TypeSortInfo = TypeSingleSortInfo | TypeSingleSortInfo[] | null;
+export type TypeSortFunction = (value1: unknown, value2: unknown, column: TypeColumn) => number | boolean;
+export type TypeSortFunctions = Record<string, TypeSortFunction>;
+export type TypeColumnSort = (value1: unknown, value2: unknown, column: TypeColumn, data1: unknown, data2: unknown, sortInfo: TypeSingleSortInfo) => number | boolean;
+export type TypeSortToolProps = {
+    column: TypeColumn;
+    columnId: string;
+    computedSortable: boolean;
+    computedSortInfo: TypeSingleSortInfo | null;
+    sortInfo: TypeSortInfo;
+    headerCell: true;
+};
+export type TypeRenderSortTool = (direction: SortDirection, extraProps: TypeSortToolProps) => React.ReactNode;
 export type TypeSingleFilterValue = {
     name: string;
     type: string;
@@ -57,7 +69,10 @@ export type TypeSingleFilterValue = {
      */
     emptyValue?: unknown;
     fn?: (arg: unknown) => unknown;
-    getFilterValue?: (...args: unknown[]) => unknown;
+    getFilterValue?: (args: {
+        data: TypeColumnRenderArgs["data"];
+        value: unknown;
+    }) => unknown;
     /**
      * If not set, runtime derives active/inactive from operator and value.
      */
@@ -125,17 +140,55 @@ export type TypeFilterType = {
     operators: TypeFilterOperator[];
 };
 export type TypeFilterTypes = Record<string, TypeFilterType>;
+export type TypeFilterParam = {
+    column?: TypeColumn;
+    data?: unknown;
+    emptyValue?: string;
+    filterValue?: string | number;
+    value?: string | number;
+};
+export type TypeFnParam = {
+    value: unknown;
+    filterValue?: unknown;
+    emptyValue?: string;
+    data?: unknown[];
+    column?: TypeColumn;
+};
+export type TypeFilter = (data: unknown[], filterValueArray: TypeSingleFilterValue[], filterTypes?: TypeFilterTypes, columnsMap?: Record<string, TypeColumn>) => unknown[] | ((item: unknown) => boolean);
 export type TypeColumnRenderArgs = {
     data: any;
     rowIndex: number;
     column: IColumn;
     columnId: string;
+    value?: any;
+    rowId?: string | number;
+    rowSelected?: boolean;
+    rowActive?: boolean;
+    cellSelected?: boolean;
+    cellActive?: boolean;
+    empty?: boolean;
+    totalDataCount?: number;
     /**
      * Raw disabledRows entry for this displayed index. Inovua exposes `null`
      * when the map is absent and `undefined` when this key is missing.
      */
     disabledRow?: boolean | null;
 };
+export type TypeInlineEditorProps = {
+    inEdit: boolean;
+    value: any;
+    startEdit: (editValue?: any, errBack?: (...args: any[]) => any) => Promise<any>;
+    onClick: (event: {
+        stopPropagation: () => void;
+    }) => void;
+    onChange: (value: any, event?: unknown) => void;
+    onComplete: (valueOrEvent?: any) => void;
+    onCancel: (event?: unknown) => void;
+    onEnterNavigation: (complete?: boolean, direction?: number, event?: unknown) => void;
+    onTabNavigation: (complete?: boolean, direction?: number, event?: unknown) => void;
+    gotoNext: () => unknown;
+    gotoPrev: () => unknown;
+};
 export type CellProps = TypeColumnRenderArgs & {
     value: any;
     cellProps: Record<string, unknown>;
@@ -152,10 +205,46 @@ export type CellProps = TypeColumnRenderArgs & {
     rtl?: boolean;
     nativeScroll?: boolean;
     editorProps?: Record<string, unknown>;
+    rendersInlineEditor?: boolean | ((cellProps: CellProps) => boolean);
+    editProps?: TypeInlineEditorProps;
     [key: string]: any;
 };
 export type TypeColumnRenderCellProps = CellProps;
 export type TypeColumnRenderFn = ((cellProps: CellProps) => React.ReactNode) | ((value: any, args: TypeColumnRenderArgs) => React.ReactNode);
+export type TypeActiveCell = [rowIndex: number, columnIndex: number] | null;
+export type TypeCellSelection = {
+    [cellKey: string]: boolean;
+} | null;
+export type TypeRowHeights = {
+    [rowId: string]: number;
+};
+export type TypeScrollProps = {
+    /** Hides custom tracks until the viewport is hovered or scrolled. */
+    autoHide?: boolean;
+    /** Space between the custom thumb and the viewport edge. */
+    scrollThumbMargin?: number;
+    /** Resting custom thumb thickness in pixels. */
+    scrollThumbWidth?: number;
+    /** Hover/drag custom thumb thickness in pixels. */
+    scrollThumbOverWidth?: number;
+    /** Custom thumb corner radius. */
+    scrollThumbRadius?: number | string;
+    /** Inline custom-track overrides. */
+    scrollTrackStyle?: React.CSSProperties;
+    /** Inline custom-thumb overrides. */
+    scrollThumbStyle?: React.CSSProperties;
+};
+export type TypeCellDOMProps = React.TdHTMLAttributes<HTMLTableCellElement> & {
+    [key: `data-${string}`]: unknown;
+};
+export type TypeHeaderDOMProps = React.ThHTMLAttributes<HTMLTableCellElement> & {
+    [key: `data-${string}`]: unknown;
+};
+export type TypeRowDOMProps = React.HTMLAttributes<HTMLTableRowElement> & {
+    [key: `data-${string}`]: unknown;
+};
+export type TypeCellDOMPropsConfig = TypeCellDOMProps | ((cellProps: CellProps) => TypeCellDOMProps | undefined);
+export type TypeHeaderDOMPropsConfig = TypeHeaderDOMProps | ((cellProps: TypeCellProps) => TypeHeaderDOMProps | undefined);
 export type TypeEditInfo = {
     rowIndex: number;
     columnIndex: number;
@@ -204,6 +293,7 @@ export type TypeColumnEditorCell = {
     cancelEdit: () => void;
     completeEdit: (value?: any) => void;
     getCurrentEditValue: () => any;
+    getEditStartValue: (cellProps?: CellProps) => Promise<any>;
     gotoNextEditor: () => unknown;
     gotoPrevEditor: () => unknown;
     onEditorEnterNavigation: (complete?: boolean, direction?: number, event?: unknown) => void;
@@ -213,10 +303,8 @@ export type TypeColumnEditorCell = {
     }) => void;
     domRef: HTMLElement | null;
     props: CellProps;
-    [key: string]: any;
 };
 export type TypeColumnEditorProps = {
-    [key: string]: any;
     value: any;
     autoFocus: boolean;
     cellProps: CellProps;
@@ -236,6 +324,16 @@ export type TypeColumnEditorProps = {
     onClick: (event: {
         stopPropagation: () => void;
     }) => void;
+    key?: React.Key;
+};
+export type TypeStartEditKeyArgs = {
+    event: React.KeyboardEvent<HTMLDivElement>;
+    data: any;
+    index: number;
+    activeItem: any;
+    activeIndex: number;
+    handle: React.MutableRefObject<TypeComputedProps | null>;
+    rowSelectionEnabled: boolean;
 };
 export type TypeColumnResizeInfo = {
     column: TypeColumn;
@@ -320,11 +418,50 @@ export type TypeRowStyleArgs = {
     style: TypeOpenRowStyleObject;
 };
 export type TypeRowStyle = TypeRowStyleObject | ((args: TypeRowStyleArgs) => TypeRowStyleObject | undefined);
+export type TypeColumnGroupHeaderProps = {
+    group: TypeColumnGroup;
+    groupName: string;
+    depth: number;
+    computedDepth: number;
+    segmentIndex: number;
+    segmentCount: number;
+    split: boolean;
+    width: number;
+    fullWidth: number;
+    columnIds: string[];
+    columns: TypeColumn[];
+    grid: TypeComputedProps;
+    computedProps: TypeComputedProps;
+    computedPropsRef: React.MutableRefObject<TypeComputedProps | null>;
+};
+export type TypeColumnGroupDOMProps = React.ThHTMLAttributes<HTMLTableCellElement> & {
+    [key: `data-${string}`]: unknown;
+};
+/**
+ * Inovua-compatible stacked-column descriptor.
+ *
+ * `group` points at another descriptor by name and creates a nested header.
+ * Header groups are derived from the live visible column order, so separated
+ * siblings render as independent segments of the same logical group.
+ */
+export type TypeColumnGroup = {
+    name: string;
+    header?: React.ReactNode | ((props: TypeColumnGroupHeaderProps) => React.ReactNode);
+    group?: string;
+    computedDepth?: number;
+    draggable?: boolean;
+    resizable?: boolean;
+    headerClassName?: string | ((props: TypeColumnGroupHeaderProps) => string | undefined);
+    headerStyle?: React.CSSProperties | ((props: TypeColumnGroupHeaderProps) => React.CSSProperties | undefined);
+    headerDOMProps?: TypeColumnGroupDOMProps | ((props: TypeColumnGroupHeaderProps) => TypeColumnGroupDOMProps | undefined);
+};
 export interface IColumn {
     name?: string;
     id?: string;
-    header?: React.ReactNode;
-    renderHeader?: (cellProps: unknown) => React.ReactNode;
+    /** Name of the stacked-column descriptor this leaf belongs to. */
+    group?: string;
+    header?: React.ReactNode | ((cellProps: TypeCellProps) => React.ReactNode);
+    renderHeader?: (cellProps: TypeCellProps) => React.ReactNode;
     /**
      * Compatibility note:
      * Inovua commonly uses `render({ value, data, ... }) => ReactNode`.
@@ -336,6 +473,12 @@ export interface IColumn {
     editable?: boolean | ((editValue: any, cellProps: CellProps) => boolean | void | Promise<boolean | void>);
     editor?: React.ElementType<any> | React.ReactElement<any>;
     editorProps?: Record<string, unknown>;
+    getEditStartValue?: (value: any, cellProps: CellProps) => any | Promise<any>;
+    /**
+     * Keeps a consumer-rendered editor mounted through `column.render`.
+     * The render callback receives lifecycle-aware `cellProps.editProps`.
+     */
+    rendersInlineEditor?: boolean | ((cellRenderObject: CellProps) => boolean);
     renderEditor?: (editorProps: TypeColumnEditorProps, cellProps: CellProps, cell: TypeColumnEditorCell) => React.ReactNode;
     width?: number;
     defaultWidth?: number;
@@ -343,6 +486,13 @@ export interface IColumn {
     maxWidth?: number;
     flex?: number | null;
     defaultFlex?: number | null;
+    /**
+     * Retains flex ownership when the user resizes this column.
+     *
+     * Inovua defaults this to true. Set false to convert an uncontrolled
+     * flex/defaultFlex column to a fixed-width column after a no-share resize.
+     */
+    keepFlex?: boolean;
     visible?: boolean;
     defaultVisible?: boolean;
     defaultHidden?: boolean;
@@ -358,6 +508,9 @@ export interface IColumn {
     locked?: "start" | "end" | true | false;
     sortable?: boolean;
     sortName?: string;
+    type?: string;
+    sort?: TypeColumnSort;
+    renderSortTool?: TypeRenderSortTool;
     filterable?: boolean;
     filterType?: string;
     filterName?: string;
@@ -367,6 +520,13 @@ export interface IColumn {
     }) => unknown;
     filterEditor?: React.ComponentType<Record<string, unknown>>;
     filterEditorProps?: unknown;
+    /**
+     * Debounce interval for committing this column's filter value.
+     *
+     * `false` and `0` commit immediately. When omitted, filter editors use the
+     * Inovua-compatible 250 ms default.
+     */
+    filterDelay?: boolean | number;
     filterCellPadding?: React.CSSProperties["padding"];
     /** Excludes this column from optional global search when false. */
     searchable?: boolean;
@@ -376,19 +536,114 @@ export interface IColumn {
     searchValue?: (data: TypeColumnRenderArgs["data"]) => unknown;
     textAlign?: "start" | "end" | "left" | "right" | "center";
     headerAlign?: "start" | "end" | "left" | "right" | "center";
-    className?: string;
-    style?: unknown;
+    cellSelectable?: boolean;
+    cellProps?: Record<string, unknown>;
+    cellDOMProps?: TypeCellDOMPropsConfig;
+    headerDOMProps?: TypeHeaderDOMPropsConfig;
+    colspan?: number | ((cellProps: CellProps) => number);
+    rowspan?: number | ((cellProps: CellProps) => number);
+    className?: string | ((cellProps: CellProps) => string | undefined);
+    style?: React.CSSProperties | ((cellProps: CellProps) => React.CSSProperties | undefined);
     headerProps?: {
         className?: string;
         style?: React.CSSProperties;
     };
-    [key: string]: unknown;
 }
 export type TypeColumn = IColumn;
 export type TypeColumns = TypeColumn[];
+export type TypeColumnWithId = TypeColumn & {
+    id: string;
+};
+export type TypeHeaderProps = {
+    style?: React.CSSProperties;
+    className?: string;
+};
 export type TypeI18n = {
     [key: string]: string | React.ReactNode;
 };
+export type TypeColumnFilterContextMenuProps = {
+    position?: string;
+    style?: React.CSSProperties;
+    constrainTo?: boolean | HTMLElement | string | ((...args: unknown[]) => HTMLElement | null);
+    alignPositions?: string[];
+    updatePositionOnScroll?: boolean;
+    selected?: string | {
+        operator: string;
+    };
+    items?: TypeContextMenuItem[];
+    onSelectionChange?: (operator: string) => void;
+    onDismiss?: () => void;
+    [key: string]: unknown;
+};
+export type TypeRenderColumnFilterContextMenu = (menuProps: TypeColumnFilterContextMenuProps, context: {
+    cellProps: TypeCellProps;
+    grid: React.MutableRefObject<TypeComputedProps | null>;
+    props: TypeComputedProps;
+}) => React.ReactNode;
+export type TypeContextMenuConstrainTo = boolean | HTMLElement | string | ((...args: unknown[]) => HTMLElement | null);
+export type TypeContextMenuPoint = {
+    left: number;
+    top: number;
+};
+export type TypeContextMenuItem = "-" | {
+    name?: string;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    checked?: boolean;
+    items?: TypeContextMenuItem[];
+    onClick?: (...args: unknown[]) => void;
+    [key: string]: unknown;
+};
+export type TypeRowProps = Partial<TypeRowStyleProps> & Pick<TypeRowStyleProps, "data" | "rowIndex"> & {
+    groupProps?: unknown;
+    empty?: boolean;
+    active?: boolean;
+    rowSelected?: boolean;
+};
+export type RowProps = TypeRowProps;
+export type TypeRenderRow = (rowProps: TypeRowDOMProps & React.RefAttributes<HTMLTableRowElement> & {
+    children?: React.ReactNode;
+    rowProps: TypeRowProps;
+}) => React.ReactNode;
+export type TypeOnRenderRow = (rowProps: TypeRowProps) => void;
+export type TypeRowClassName = string | ((rowProps: TypeRowProps) => string | undefined);
+export type TypeOnRowClick = (rowProps: TypeRowProps, event: React.MouseEvent<HTMLTableRowElement>) => void;
+export type TypeOnRowDoubleClick = (event: React.MouseEvent<HTMLTableRowElement>, rowProps: TypeRowProps) => void;
+export type TypeOnCellClick = (event: React.MouseEvent<HTMLTableCellElement>, cellProps: CellProps) => void;
+export type TypeOnCellDoubleClick = TypeOnCellClick;
+export type TypeColumnContextMenuProps = {
+    autoFocus?: boolean;
+    alignTo?: HTMLElement | TypeContextMenuPoint | null;
+    alignPositions?: string[];
+    cellProps?: TypeCellProps;
+    constrainTo?: TypeContextMenuConstrainTo;
+    items?: TypeContextMenuItem[];
+    nativeScroll?: boolean;
+    onDismiss?: () => void;
+    position?: string;
+    style?: React.CSSProperties;
+    theme?: string;
+    updatePositionOnScroll?: boolean;
+    [key: string]: unknown;
+};
+export type TypeRowContextMenuProps = TypeColumnContextMenuProps & {
+    rowProps?: TypeRowProps;
+};
+export type TypeRenderColumnContextMenu = (menuProps: TypeColumnContextMenuProps, context: {
+    cellProps: TypeCellProps;
+    grid: TypeComputedProps;
+    computedProps: TypeComputedProps;
+    computedPropsRef: React.MutableRefObject<TypeComputedProps | null>;
+}) => React.ReactNode;
+export type TypeRenderRowContextMenu = (menuProps: TypeRowContextMenuProps, context: {
+    rowProps: TypeRowProps;
+    cellProps?: TypeCellProps;
+    grid: TypeComputedProps;
+    computedProps: TypeComputedProps;
+    computedPropsRef: React.MutableRefObject<TypeComputedProps | null>;
+}) => React.ReactNode;
+export type TypeContextMenuEvent = React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement> | React.PointerEvent<HTMLElement>;
+export type TypeOnRowContextMenu = (rowProps: TypeRowProps, event: TypeContextMenuEvent) => void;
 /**
  * Inovua selection in your codebase is an object map: { [id]: rowObject }.
  * We accept broad shapes, and the runtime also tolerates the emitted
@@ -400,6 +655,7 @@ export type TypeRowSelection = string | number | boolean | {
 export type TypeBoolMap = {
     [key: string]: boolean;
 };
+export type TypeRowUnselected = TypeBoolMap | null;
 export type TypeOnSelectionChangeArg = {
     selected: TypeRowSelection;
     data?: unknown;
@@ -420,6 +676,52 @@ export type TypeComputedColumn = TypeColumn & {
     index?: number;
 };
 export type TypeComputedColumnsMap = Record<string, TypeComputedColumn>;
+export type TypeWithId = {
+    id: string;
+};
+export interface TypeBatchUpdateQueue {
+    (fn: () => void): void;
+    commit: (extraFn?: () => void) => void;
+}
+export type TypeDragHelper = {
+    onDrag: (...args: unknown[]) => unknown;
+    onDrop: (...args: unknown[]) => unknown;
+};
+export type TypeConstrainRegion = {
+    0: number;
+    1: number;
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+    _events: object;
+    _eventsCount: number;
+    _maxListeners: number;
+    height: number;
+    width: number;
+    getHeight?: () => number;
+};
+export type TypeDiff = {
+    top: number;
+    left: number;
+};
+export type TypeConfig = {
+    diff: TypeDiff;
+    didDrag: boolean;
+    scope?: unknown;
+};
+export type RangeResultType = {
+    top: number;
+    bottom: number;
+    height: number;
+    index: number;
+    group?: boolean;
+    keyPath?: string[] | string;
+    leaf?: boolean;
+    value?: string;
+    depth?: number;
+    parent?: boolean;
+};
 export type TypeSize = {
     width: number;
     height: number;
@@ -497,12 +799,6 @@ export type TypeComputedVirtualList = {
     getMaxRenderCount: () => number;
 };
 export type TypeComputedProps = {
-    /**
-     * Inovua exposes a very broad computed-props object.
-     * Keep this type intentionally open so legacy property access continues
-     * to type-check even when our runtime only implements a compat subset.
-     */
-    [key: string]: any;
     reload: () => void;
     initialProps?: unknown;
     publicAPI?: TypeComputedProps;
@@ -510,6 +806,7 @@ export type TypeComputedProps = {
     originalData?: unknown[];
     count?: number;
     dataCountAfterFilter?: number;
+    filteredRowsCount?: (filteredRows: number) => void;
     getData: () => unknown[];
     getCount: () => number;
     computedSkip?: number;
@@ -519,12 +816,14 @@ export type TypeComputedProps = {
     setSkip: (skip: number) => void;
     setLimit: (limit: number) => void;
     computedSortInfo?: TypeSortInfo;
+    computedIsMultiSort?: boolean;
     getSortInfo: () => TypeSortInfo;
     setSortInfo: (sortInfo: TypeSortInfo) => void;
     toggleColumnSort?: (column: TypeGetColumnByParam) => void;
     setColumnSortInfo?: (column: TypeGetColumnByParam, dir: SortDirection) => void;
     unsortColumn?: (column: TypeGetColumnByParam) => void;
     computedFilterValue?: TypeFilterValue;
+    computedFiltered?: boolean;
     computedFilterValueMap?: Record<string, TypeSingleFilterValue> | null;
     getFilterValue: () => TypeFilterValue;
     setFilterValue: (filterValue: TypeFilterValue) => void;
@@ -544,9 +843,32 @@ export type TypeComputedProps = {
     completeEdit?: (args?: TypeCompleteEditArgs) => void;
     cancelEdit?: (args?: TypeCancelEditArgs) => void;
     currentEditCompletePromise?: React.MutableRefObject<Promise<unknown>>;
+    computedRowHeights?: TypeRowHeights;
+    setRowHeights?: (rowHeights: TypeRowHeights) => void;
+    setRowHeightById: (rowHeight: number | null, id: string | number) => void;
+    getRowHeightById: (id: string | number) => number;
+    getRowHeight?: (rowIndex: number) => number;
     computedColumnOrder?: string[] | undefined;
     getColumnOrder: () => string[];
     setColumnOrder: (columnOrder: string[]) => void;
+    columnSizes?: Record<string, number>;
+    columnFlexes?: Record<string, number>;
+    setColumnSizes?: React.Dispatch<React.SetStateAction<Record<string, number>>>;
+    setColumnFlexes?: React.Dispatch<React.SetStateAction<Record<string, number | null>>>;
+    onBatchColumnResize?: (info: TypeColumnResizeInfo[], context?: TypeColumnResizeContext) => void;
+    computedOnColumnResize?: (args: {
+        index: number;
+        diff: number;
+    }) => void;
+    setColumnsSizesAuto?: (config?: {
+        columnIds?: string[];
+        skipHeader?: boolean;
+        skipSortTool?: boolean;
+    }) => void;
+    setColumnSizesToFit?: () => void;
+    setColumnSizeAuto?: (id: string, skipHeader?: boolean) => void;
+    reservedViewportWidth?: number;
+    setReservedViewportWidth?: React.Dispatch<React.SetStateAction<number>>;
     columnsMap?: TypeComputedColumnsMap;
     visibleColumnsMap?: TypeComputedColumnsMap;
     allColumns?: TypeComputedColumn[];
@@ -602,11 +924,16 @@ export type TypeComputedProps = {
     setEnableFiltering?: (value: React.SetStateAction<boolean>) => void;
     computedShowHeader?: boolean;
     setShowHeader?: (value: React.SetStateAction<boolean>) => void;
+    computedShowHoverRows?: boolean;
+    setShowHoverRows?: React.Dispatch<React.SetStateAction<boolean>>;
     computedShowZebraRows: boolean;
     setShowZebraRows: (value: React.SetStateAction<boolean>) => void;
+    computedShowEmptyRows?: boolean;
+    setShowEmptyRows?: React.Dispatch<React.SetStateAction<boolean>>;
     showHorizontalCellBorders?: boolean;
     showVerticalCellBorders?: boolean;
     computedShowCellBorders?: TypeShowCellBorders;
+    setShowCellBorders?: React.Dispatch<React.SetStateAction<TypeShowCellBorders>>;
     computedRemoteData?: boolean;
     computedRemotePagination?: boolean;
     computedRemoteFilter?: boolean;
@@ -614,22 +941,45 @@ export type TypeComputedProps = {
     computedPagination?: boolean;
     computedLivePagination?: boolean;
     remoteSort?: boolean;
+    loadNextPage?: () => void;
+    paginationCount?: number;
+    paginationProps?: TypePaginationProps;
+    hasNextPage?: () => boolean;
+    hasPrevPage?: () => boolean;
+    gotoNextPage?: () => void;
+    gotoPrevPage?: () => void;
+    gotoFirstPage?: () => void;
+    gotoLastPage?: () => void;
     getItemId?: (item: object) => unknown;
     getItemAt?: (index: number) => unknown;
     getItemIdAt?: (index: number) => unknown;
     getItemIndex?: (id: string | number) => number;
     getRowIndexById?: (rowId: string | number, data?: unknown[]) => number;
     getItemIndexById?: (rowId: string | number, data?: unknown[]) => number;
+    setItemPropertyAt?: (index: number, property: string, value: unknown) => void;
+    setItemPropertyForId?: (id: string | number, property: string, value: unknown) => void;
+    setItemAt?: (index: number, item: unknown, config?: {
+        replace?: boolean;
+        property?: string;
+        value?: unknown;
+        deepCloning?: boolean;
+    }) => void;
+    setItemsAt?: (items: unknown[] | Record<number, unknown>, config?: {
+        replace?: boolean;
+    }) => void;
     computedSelected?: TypeRowSelection;
     computedUnselected?: TypeBoolMap | null;
     computedRowSelectionEnabled?: boolean;
     computedRowMultiSelectionEnabled?: boolean;
     getSelectedMap?: () => Record<string, unknown>;
     setSelected?: (selected: TypeRowSelection, ...args: unknown[]) => void;
+    setUnselected?: React.Dispatch<React.SetStateAction<TypeRowUnselected>>;
     selectAll?: () => void;
     deselectAll?: () => void;
     isRowSelected?: (data: object | number | string) => boolean;
     getSelectedCount?: (selected?: TypeRowSelection, unselected?: TypeRowSelection) => number;
+    getUnselectedCount?: (unselected?: TypeRowUnselected) => number;
+    isSelectionEmpty?: () => boolean;
     computedSelectedCount?: number;
     computedUnselectedCount?: number;
     setSelectedById?: (id: string, selected: boolean) => void;
@@ -637,19 +987,67 @@ export type TypeComputedProps = {
     setRowSelected?: (index: number, selected: boolean, event?: unknown) => void;
     computedActiveIndex?: number;
     computedLastActiveIndex?: number | null;
+    doSetLastActiveIndex?: (activeIndex: number | null) => void;
     computedActiveItem?: unknown;
     computedHasRowNavigation?: boolean;
     computedFocused?: boolean;
+    computedSetFocused?: React.Dispatch<React.SetStateAction<boolean>>;
+    computedOnKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    computedOnFocus?: React.FocusEventHandler<HTMLDivElement>;
+    toggleActiveRowSelection?: (event?: {
+        ctrlKey?: boolean;
+        metaKey?: boolean;
+        shiftKey?: boolean;
+    }) => void;
+    computedOnRowClick?: (event: React.MouseEvent<HTMLTableRowElement>, rowProps: TypeRowProps) => void;
+    computedRowDoubleClick?: TypeOnRowDoubleClick;
+    computedCellDoubleClick?: TypeOnCellDoubleClick;
     setActiveIndex?: (activeIndex: number) => void;
     incrementActiveIndex?: (increment: number) => void;
     getActiveItem?: () => unknown;
+    computedActiveCell?: TypeActiveCell;
+    computedCellSelection?: TypeCellSelection;
+    computedCellSelectionEnabled?: boolean;
+    computedCellMultiSelectionEnabled?: boolean;
+    computedCellNavigationEnabled?: boolean;
+    computedCellSelectionByIndex?: boolean;
+    getActiveCell?: () => TypeActiveCell;
+    setActiveCell?: (activeCell: TypeActiveCell) => void;
+    getCellSelection?: () => TypeCellSelection;
+    setCellSelection?: (selection: TypeCellSelection) => void;
+    isCellSelected?: (cell: TypeActiveCell | {
+        rowIndex: number;
+        columnIndex: number;
+    }) => boolean;
+    getCellSelectionIdKey?: (rowIndex: number, columnIndex: number) => string | number;
+    getCellSelectionKey?: (cell: string | number | TypeCellProps, column?: TypeGetColumnByParam) => string | number;
+    incrementActiveCell?: (direction: [number, number]) => void;
+    toggleActiveCellSelection?: (event?: {
+        shiftKey?: boolean;
+        ctrlKey?: boolean;
+        metaKey?: boolean;
+    }) => void;
+    getCellSelectionBetween?: (start?: TypeActiveCell, end?: TypeActiveCell) => Record<string, boolean>;
+    isCellVisible?: (cell: {
+        rowIndex: number;
+        columnIndex: number;
+    }) => boolean | {
+        topDiff: number;
+        bottomDiff: number;
+        leftDiff: number;
+        rightDiff: number;
+    };
     setScrollLeft?: (scrollLeft: number) => void;
     incrementScrollLeft?: (scrollLeft: number) => void;
     getScrollLeft?: () => number;
     getScrollLeftMax?: () => number;
+    /** Logical horizontal offset; writable in both LTR and RTL mode. */
+    scrollLeft?: number;
     setScrollTop?: (scrollTop: number) => void;
     incrementScrollTop?: (scrollTop: number) => void;
     getScrollTop?: () => number;
+    /** Vertical offset; writable in both native and custom-scrollbar modes. */
+    scrollTop?: number;
     scrollToIndex?: TypeScrollToIndex;
     scrollToId?: (id: string | number, config?: TypeScrollToIndexConfig, callback?: (...args: unknown[]) => void) => void;
     scrollToCell?: (cell: {
@@ -680,14 +1078,50 @@ export type TypeComputedProps = {
         vertical: boolean;
         horizontal: boolean;
     };
+    virtualizeColumns?: boolean;
+    computedEnableRowspan?: boolean;
+    computedHasColSpan?: boolean;
+    computedEnableColumnHover?: boolean;
+    availableWidth?: number;
+    edition?: "community";
+    computedLicenseValid?: boolean;
+    getColumnLayout?: () => unknown;
+    computedShowHeaderBorderRight?: boolean;
+    silentSetData?: React.Dispatch<React.SetStateAction<any[]>>;
+    setOriginalData?: React.Dispatch<React.SetStateAction<any[]>>;
     i18n?: (key: string, defaultValue?: string) => string | React.ReactNode;
+    getMenuAvailableHeight?: () => number;
+    isFilterable?: () => boolean;
+    shouldShowFilteringMenuItems?: () => boolean;
+    updateMenuPositions?: () => void;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    rtlOffset?: number;
     columnFilterContextMenuProps?: Record<string, unknown> | null;
     showColumnFilterContextMenu?: (...args: unknown[]) => void;
     hideColumnFilterContextMenu?: () => void;
-    showColumnContextMenu?: (...args: unknown[]) => void;
-    hideColumnContextMenu?: (...args: unknown[]) => void;
-    showRowContextMenu?: (...args: unknown[]) => void;
-    hideRowContextMenu?: (...args: unknown[]) => void;
+    columnContextMenuProps?: TypeColumnContextMenuProps | null;
+    rowContextMenuProps?: TypeRowContextMenuProps | null;
+    showColumnContextMenu?: (alignTo: HTMLElement | TypeContextMenuPoint, cellProps: TypeCellProps, config?: {
+        computedVisibleIndex?: number;
+    }, onHide?: () => void) => void;
+    hideColumnContextMenu?: () => void;
+    showRowContextMenu?: (alignTo: HTMLElement | TypeContextMenuPoint, rowProps: TypeRowProps, cellProps?: TypeCellProps, onHide?: () => void) => void;
+    hideRowContextMenu?: () => void;
+    getState?: () => {
+        data: unknown[];
+        count: number;
+        skip: number;
+        limit: number;
+        sortInfo: TypeSortInfo;
+        filterValue: TypeFilterValue;
+        selected: TypeRowSelection;
+        unselected: TypeRowUnselected;
+        activeIndex: number;
+        activeCell: TypeActiveCell;
+        cellSelection: TypeCellSelection;
+        columnOrder: string[];
+        rowHeights: TypeRowHeights;
+    };
 };
 export type TypePaginationMode = true | false | "remote" | "local";
 /**
@@ -786,14 +1220,41 @@ export type TypeDataGridProps = {
     idProperty: string;
     columns: TypeColumns;
     dataSource: TypeDataSource;
+    /** Stacked and nested column-header descriptors. */
+    groups?: TypeColumnGroup[];
+    /**
+     * When false, leaf and group drag operations stay inside their existing
+     * group parent. The Inovua Community default is true.
+     */
+    allowGroupSplitOnReorder?: boolean;
     columnOrder?: string[];
+    defaultColumnOrder?: string[];
     onColumnOrderChange?: (columnOrder: string[]) => void;
+    onColumnVisibleChange?: (args: {
+        column: TypeColumn;
+        visible: boolean;
+    }) => void;
     /**
      * In Inovua, `reorderColumns={false}` is common.
      * We support it explicitly now.
      */
     reorderColumns?: boolean;
     resizable?: boolean;
+    /** Root fallback used when a column has no width/defaultWidth. */
+    columnDefaultWidth?: number;
+    /** Root fallback used when a column has no minWidth. */
+    columnMinWidth?: number;
+    /** Root fallback used when a column has no maxWidth. */
+    columnMaxWidth?: number | null;
+    /**
+     * Resizes the adjacent visible column in the opposite direction so the
+     * pair keeps its total rendered width.
+     */
+    shareSpaceOnResize?: boolean;
+    /** Pointer target width, in pixels, for header resize handles. */
+    columnResizeHandleWidth?: number;
+    /** Rendered width, in pixels, of the deferred resize proxy. */
+    columnResizeProxyWidth?: number;
     /**
      * When enabled, the rendered column follows the pointer while its resize
      * handle is dragged. The default deferred mode keeps the lightweight resize
@@ -820,10 +1281,30 @@ export type TypeDataGridProps = {
     onFilterValueChange?: (filterValue: TypeFilterValue) => void;
     onColumnFilterValueChange?: (columnFilterValue: TypeColumnFilterValueChangeArg) => void;
     filterTypes?: TypeFilterTypes;
+    scrollTopOnFilter?: boolean;
+    renderColumnFilterContextMenu?: TypeRenderColumnFilterContextMenu;
+    columnFilterContextMenuAlignPositions?: string[];
+    columnFilterContextMenuConstrainTo?: boolean | HTMLElement | string | ((...args: unknown[]) => HTMLElement | null);
+    columnFilterContextMenuPosition?: string;
+    updateMenuPositionOnScroll?: boolean;
+    renderColumnContextMenu?: TypeRenderColumnContextMenu;
+    columnContextMenuAlignPositions?: string[];
+    columnContextMenuConstrainTo?: TypeContextMenuConstrainTo;
+    columnContextMenuPosition?: string;
+    renderRowContextMenu?: TypeRenderRowContextMenu;
+    onRowContextMenu?: TypeOnRowContextMenu;
+    rowContextMenuAlignPositions?: string[];
+    rowContextMenuConstrainTo?: TypeContextMenuConstrainTo;
+    rowContextMenuPosition?: string;
+    updateMenuPositionOnColumnsChange?: boolean;
     filteredRowsCount?: (filteredRows: number) => void;
     sortInfo?: TypeSortInfo;
     defaultSortInfo?: TypeSortInfo;
     onSortInfoChange?: (sortInfo: TypeSortInfo) => void;
+    sortable?: boolean;
+    sortFunctions?: TypeSortFunctions | null;
+    renderSortTool?: TypeRenderSortTool;
+    scrollTopOnSort?: boolean | "always";
     allowUnsort?: boolean;
     defaultSortingDirection?: "desc" | "asc";
     pagination?: TypePaginationMode;
@@ -836,6 +1317,18 @@ export type TypeDataGridProps = {
     pageSizes?: number[];
     renderPaginationToolbar?: (paginationProps: TypePaginationProps) => React.ReactNode;
     virtualized?: boolean;
+    /**
+     * Uses the browser's visible scrollbars when true. The default false mode
+     * keeps native overflow semantics while rendering shadcn-compatible custom
+     * tracks and thumbs.
+     */
+    nativeScroll?: boolean;
+    scrollProps?: TypeScrollProps;
+    initialScrollTop?: number;
+    initialScrollLeft?: number;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    /** Mirrors horizontal layout and exposes logical scroll offsets. */
+    rtl?: boolean;
     /**
      * Enables horizontal column virtualization when the grid has at least this
      * many visible columns. The boundary is inclusive and defaults to `15`.
@@ -868,19 +1361,41 @@ export type TypeDataGridProps = {
     emptyText?: React.ReactNode | (() => React.ReactNode);
     showColumnMenuTool?: boolean;
     rowHeight?: number | ((rowIndex: number) => number) | null;
+    rowHeights?: TypeRowHeights;
+    defaultRowHeights?: TypeRowHeights;
+    onRowHeightsChange?: (rowHeights: TypeRowHeights) => void;
+    onUpdateRowHeights?: (heights: {
+        [rowIndex: number]: number;
+    }, computedProps: TypeComputedProps) => void;
     minRowHeight?: number;
     maxRowHeight?: number;
     rowStyle?: TypeRowStyle;
+    rowProps?: TypeRowDOMProps | ((rowProps: TypeRowProps) => TypeRowDOMProps | undefined);
+    rowClassName?: TypeRowClassName;
+    renderRow?: TypeRenderRow;
+    onRenderRow?: TypeOnRenderRow;
+    onRowClick?: TypeOnRowClick;
+    onRowDoubleClick?: TypeOnRowDoubleClick;
+    onCellClick?: TypeOnCellClick;
+    onCellDoubleClick?: TypeOnCellDoubleClick;
+    cellDOMProps?: TypeCellDOMPropsConfig;
+    headerDOMProps?: TypeHeaderDOMPropsConfig;
+    showHoverRows?: boolean;
+    showEmptyRows?: boolean;
     showZebraRows?: boolean;
     defaultShowZebraRows?: boolean;
     editable?: boolean;
     editStartEvent?: string;
+    isStartEditKeyPressed?: (args: TypeStartEditKeyArgs) => boolean;
+    autoFocusOnEditComplete?: boolean;
+    autoFocusOnEditEscape?: boolean;
     onEditStart?: (editInfo: TypeEditInfo) => void;
     onEditStop?: (editInfo: TypeEditInfo) => void;
     onEditComplete?: (editInfo: TypeEditInfo) => void | Promise<unknown>;
     onEditCancel?: (editInfo: TypeEditInfo) => void;
     onEditValueChange?: (editInfo: TypeEditInfo) => void;
     onColumnResize?: (info: TypeColumnResizeInfo, context: TypeColumnResizeContext) => void;
+    onBatchColumnResize?: (info: TypeColumnResizeInfo[], context: TypeColumnResizeContext) => void;
     headerHeight?: number;
     filterRowHeight?: number;
     loading?: boolean;
@@ -909,6 +1424,15 @@ export type TypeDataGridProps = {
     checkboxOnlyRowSelect?: boolean;
     checkboxSelectEnableShiftKey?: boolean;
     toggleRowSelectOnClick?: boolean;
+    activeCell?: TypeActiveCell;
+    defaultActiveCell?: TypeActiveCell;
+    onActiveCellChange?: (activeCell: TypeActiveCell) => void;
+    activeCellThrottle?: number;
+    cellSelection?: TypeCellSelection;
+    defaultCellSelection?: TypeCellSelection;
+    onCellSelectionChange?: (cellSelection: TypeCellSelection) => void;
+    cellSelectionByIndex?: boolean;
+    toggleCellSelectOnClick?: boolean;
     activeIndex?: number;
     defaultActiveIndex?: number;
     onActiveIndexChange?: (activeIndex: number) => void;
@@ -938,12 +1462,34 @@ export type TypeDataGridProps = {
      */
     onDidMount?: (computedPropsRef: React.MutableRefObject<TypeComputedProps | null>) => void;
     onReady?: (computedPropsRef: React.MutableRefObject<TypeComputedProps | null>) => void;
-    handle?: (gridApiRef: React.MutableRefObject<TypeComputedProps | null>) => void;
+    handle?: (gridApiRef: React.MutableRefObject<TypeComputedProps | null> | null) => void;
     className?: string;
     style?: React.CSSProperties;
     onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
     onFocus?: React.FocusEventHandler<HTMLDivElement>;
     onBlur?: React.FocusEventHandler<HTMLDivElement>;
 };
+/**
+ * Executable descriptor for an internally implemented Community feature.
+ *
+ * the-datagrid does not require consumers to install plugins. These
+ * descriptors expose the equivalent built-in behavior for compatibility and
+ * diagnostics without pretending that an empty placeholder is functional.
+ */
+export type TypePlugin = {
+    readonly name: string;
+    hook: (props: TypeDataGridProps, computedProps: TypeComputedProps, computedPropsRef: React.MutableRefObject<TypeComputedProps | null>) => unknown;
+    defaultProps?: () => Record<string, unknown>;
+    maybeAddColumns?: (columns: TypeColumns, props: Record<string, unknown>) => TypeColumns;
+    renderColumnContextMenu?: (computedProps: TypeComputedProps, computedPropsRef: React.MutableRefObject<TypeComputedProps | null>) => React.ReactNode;
+    renderRowContextMenu?: (computedProps: TypeComputedProps, computedPropsRef: React.MutableRefObject<TypeComputedProps | null>) => React.ReactNode;
+    renderColumnFilterContextMenu?: (computedProps: TypeComputedProps, computedPropsRef: React.MutableRefObject<TypeComputedProps | null>) => React.ReactNode;
+};
+export type TypeCommunityPlugin = TypePlugin & {
+    readonly name: "sortable-columns" | "filters" | "menus" | "cell-selection";
+    readonly methods: readonly (keyof TypeComputedProps)[];
+    isEnabled: (props: Readonly<TypeDataGridProps>) => boolean;
+    getState: (computedProps: Readonly<TypeComputedProps>) => unknown;
+};
 export {};
 //# sourceMappingURL=types.d.ts.map