@ozen-ui/data-grid 0.76.0 → 0.78.0

package/__inner__/esm/ui/DataGrid/components/DataGridRow/DataGridRow.js

@@ -19,9 +19,13 @@ export var DataGridRow = dataGridObserver(function (_a) {
             store.columns.map(function (column) {
                 var cell = column.cell;
                 var value = column.accessor(row, index);
-                var renderedCell = isFunction(cell)
-                    ? cell(value, row, index)
-                    : cell;
+                var renderedCell = (function () {
+                    if (isFunction(cell)) {
+                        var Component = cell;
+                        return (React.createElement(Component, { key: "".concat(column.id, "-").concat(index), data: value, item: row, index: index, column: column }));
+                    }
+                    return cell;
+                })();
                 var cellComponent = (function () {
                     if (isString(renderedCell) || isNumber(renderedCell)) {
                         return (React.createElement(DataGridCellItem, { align: column.align }, renderedCell));

package/__inner__/esm/ui/DataGrid/components/DataGridSubRow/DataGridSubRow.js

@@ -23,7 +23,7 @@ export var DataGridSubRow = dataGridObserver(function (_a) {
         ? store.subRows.getIsExpandedRoot(id)
         : !!((_c = subRow.root) === null || _c === void 0 ? void 0 : _c.getIsExpanded(id));
     var canExpand = subRow.canExpand;
-    var rendered = subRow.render(row, index);
+    var Component = subRow.render;
     var expandButton = (React.createElement(IconButton, { icon: subRow.getIsExpanded(id) ? ChevronUpIcon : ChevronDownIcon, size: "s", onClick: function () {
             subRow.toggle(id);
         }, compressed: true }));
@@ -43,7 +43,7 @@ export var DataGridSubRow = dataGridObserver(function (_a) {
                         canExpand &&
                         store.subRows.isLeft &&
                         expandButton,
-                    rendered,
+                    React.createElement(Component, { subRow: subRow, index: index, item: row }),
                     isSomeRowsVisible &&
                         canExpand &&
                         store.subRows.isRight &&

package/__inner__/esm/ui/DataGridAllFiltersDrawer/DataGridAllFiltersDrawer.js

@@ -1,4 +1,5 @@
-import React from 'react';
+import { __assign, __rest } from "tslib";
+import React, { forwardRef } from 'react';
 import { Drawer, DrawerBody, DrawerHeader, DrawerSubtitle, DrawerTitle, } from "@ozen-ui/kit/DrawerNext";
 import { Stack } from "@ozen-ui/kit/Stack";
 import { useEventListener } from "@ozen-ui/kit/useEventListener";
@@ -6,8 +7,8 @@ import { isKey } from '@ozen-ui/kit/utils';
 import { dataGridObserver, useDataGridStore } from '../../core';
 import { DataGridFilter } from '../filters';
 import { DataGridAllFiltersDrawerFooter } from './components';
-export var DataGridAllFiltersDrawer = dataGridObserver(function (_a) {
-    var title = _a.title, subTitle = _a.subTitle, applyButton = _a.applyButton, closeButton = _a.closeButton;
+var NonWrappedDataGridAllFiltersDrawer = forwardRef(function (_a, ref) {
+    var title = _a.title, subTitle = _a.subTitle, applyButton = _a.applyButton, closeButton = _a.closeButton, onClose = _a.onClose, other = __rest(_a, ["title", "subTitle", "applyButton", "closeButton", "onClose"]);
     var store = useDataGridStore();
     var isOpen = store.modals.isOpen('filters');
     var filters = store.filters;
@@ -21,7 +22,10 @@ export var DataGridAllFiltersDrawer = dataGridObserver(function (_a) {
             store.modals.closeFilters();
         },
     });
-    return (React.createElement(Drawer, { open: isOpen, onClose: function () { return store.modals.closeFilters(); } },
+    return (React.createElement(Drawer, __assign({}, other, { ref: ref, open: isOpen, onClose: function () {
+            store.modals.closeFilters();
+            onClose === null || onClose === void 0 ? void 0 : onClose();
+        } }),
         React.createElement(DrawerHeader, null,
             React.createElement(DrawerTitle, null, title),
             subTitle && React.createElement(DrawerSubtitle, null, subTitle)),
@@ -29,3 +33,5 @@ export var DataGridAllFiltersDrawer = dataGridObserver(function (_a) {
             React.createElement(Stack, { direction: "column", gap: "s", fullWidth: true }, filters.filters.map(function (filter) { return (React.createElement(DataGridFilter, { key: filter.id, filter: filter, type: "allFilter" })); }))),
         React.createElement(DataGridAllFiltersDrawerFooter, { applyButton: applyButton, closeButton: closeButton })));
 });
+NonWrappedDataGridAllFiltersDrawer.displayName = 'DataGridAllFiltersDrawer';
+export var DataGridAllFiltersDrawer = dataGridObserver(NonWrappedDataGridAllFiltersDrawer);

package/__inner__/esm/ui/DataGridSettingsDrawer/DataGridSettingsDrawer.js

@@ -1,11 +1,11 @@
-import { __assign, __read } from "tslib";
-import React, { useMemo, useState } from 'react';
+import { __assign, __read, __rest } from "tslib";
+import React, { forwardRef, useMemo, useState } from 'react';
 import { Checkbox } from "@ozen-ui/kit/CheckboxNext";
 import { Drawer, DrawerBody, DrawerFooter, DrawerFooterButton, DrawerFooterButtonsGroup, DrawerHeader, DrawerSubtitle, DrawerTitle, } from "@ozen-ui/kit/DrawerNext";
 import { FormGroup } from "@ozen-ui/kit/FormGroup";
 import { dataGridObserver, useDataGridStore } from '../../core';
-export var DataGridSettingsDrawer = dataGridObserver(function (_a) {
-    var title = _a.title, subTitle = _a.subTitle, closeButton = _a.closeButton, applyButton = _a.applyButton;
+var NonWrappedDataGridSettingsDrawer = forwardRef(function (_a, ref) {
+    var title = _a.title, subTitle = _a.subTitle, closeButton = _a.closeButton, applyButton = _a.applyButton, onClose = _a.onClose, other = __rest(_a, ["title", "subTitle", "closeButton", "applyButton", "onClose"]);
     var store = useDataGridStore();
     var isOpen = store.modals.isOpen('columns-settings');
     var columns = store.allColumns;
@@ -34,14 +34,18 @@ export var DataGridSettingsDrawer = dataGridObserver(function (_a) {
             setLocalVisible({});
         }
     }, [isOpen]);
-    return (React.createElement(Drawer, { open: isOpen, onClose: function () { return store.modals.closeColumnsSettings(); } },
+    return (React.createElement(Drawer, __assign({}, other, { ref: ref, open: isOpen, onClose: function () {
+            store.modals.closeColumnsSettings();
+            onClose === null || onClose === void 0 ? void 0 : onClose();
+        } }),
         React.createElement(DrawerHeader, null,
             React.createElement(DrawerTitle, null, title),
             subTitle && React.createElement(DrawerSubtitle, null, subTitle)),
         React.createElement(DrawerBody, null,
             React.createElement(FormGroup, { size: "l", direction: "column" }, columns.map(function (column) {
                 var checked = checkIsSelected(column);
-                return (React.createElement(Checkbox, { key: column.id, label: column.name, checked: checked, disabled: isLeftAlone && checked, size: "l", onChange: function (event) {
+                var NameComponent = column.name;
+                return (React.createElement(Checkbox, { key: column.id, label: React.createElement(NameComponent, null), checked: checked, disabled: isLeftAlone && checked, size: "l", onChange: function (event) {
                         setLocalVisible(function (previousVisible) {
                             var _a;
                             return (__assign(__assign({}, previousVisible), (_a = {}, _a[column.id] = event.target.checked, _a)));
@@ -58,3 +62,5 @@ export var DataGridSettingsDrawer = dataGridObserver(function (_a) {
                         store.modals.closeColumnsSettings();
                     } }, applyButton)))));
 });
+NonWrappedDataGridSettingsDrawer.displayName = 'DataGridSettingsDrawer';
+export var DataGridSettingsDrawer = dataGridObserver(NonWrappedDataGridSettingsDrawer);

package/__inner__/esm/ui/filters/DataGridAutocompleteFilter/DataGridAutocompleteFilter.js

@@ -6,19 +6,7 @@ import { filterValueToAutocomplete, autocompleteValueToFilter } from './utilts';
 export var DataGridAutocompleteFilter = dataGridObserver(function (_a) {
     var filter = _a.filter, type = _a.type, onChange = _a.onChange, onInputChange = _a.onInputChange, style = _a.style, renderMoreTag = _a.renderMoreTag, renderOption = _a.renderOption, searchFunction = _a.searchFunction, other = __rest(_a, ["filter", "type", "onChange", "onInputChange", "style", "renderMoreTag", "renderOption", "searchFunction"]);
     var value = filter.valueByType(type);
-    return (React.createElement(Autocomplete, __assign({ disableCloseOnSelect: filter.isMultiple, limitTags: "responsive", label: filter.name }, other, { size: type === 'allFilter' ? 's' : 'xs', options: filter.options, getOptionKey: function (option) { return option.value; }, getOptionLabel: function (option) { return option.label; }, getOptionDisabled: function () { return false; }, multiple: filter.isMultiple, renderMoreTag: renderMoreTag
-            ? function (props, ref) {
-                return renderMoreTag(props, ref);
-            }
-            : undefined, renderOption: renderOption
-            ? function (props) {
-                return renderOption(props);
-            }
-            : undefined, searchFunction: searchFunction
-            ? function (options, searchValue) {
-                return searchFunction(options, searchValue);
-            }
-            : undefined, value: filterValueToAutocomplete(filter, value), style: __assign(__assign({}, style), { minWidth: 200 }), onInputChange: function (event, _value) {
+    return (React.createElement(Autocomplete, __assign({ disableCloseOnSelect: filter.isMultiple, limitTags: "responsive", label: filter.name }, other, { size: type === 'allFilter' ? 's' : 'xs', options: filter.options, getOptionKey: function (option) { return option.value; }, getOptionLabel: function (option) { return option.label; }, getOptionDisabled: function () { return false; }, multiple: filter.isMultiple, renderMoreTag: renderMoreTag, renderOption: renderOption, searchFunction: searchFunction, value: filterValueToAutocomplete(filter, value), style: __assign(__assign({}, style), { minWidth: 200 }), onInputChange: function (event, _value) {
             var value = _value !== null && _value !== void 0 ? _value : '';
             onInputChange === null || onInputChange === void 0 ? void 0 : onInputChange(event, value);
         }, onChange: function (event, _value) {

package/__inner__/types/core/column/hooks/useDataGridColumn.d.ts

@@ -1,3 +1,4 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridColumn } from '../table';
-export declare const useDataGridColumn: <Item extends unknown, AccessorReturn>(column: DataGridColumn<Item, AccessorReturn>, store?: DataGridStore<Item>) => import("..").DataGridStoreColumn<Item, AccessorReturn>;
+export declare const useDataGridColumn: <Item extends DataGridItem, AccessorReturn>(column: DataGridColumn<Item, AccessorReturn>, store?: DataGridStore<Item>) => import("..").DataGridStoreColumn<Item, AccessorReturn>;

package/__inner__/types/core/column/hooks/useDataGridColumnEvents.d.ts

@@ -1,5 +1,6 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStoreColumnEvents } from '../store';
 import type { DataGridColumn } from '../table';
-export declare const useDataGridColumnEvents: <Item extends unknown, AccessorReturn>(column: DataGridColumn<Item, AccessorReturn>, subscribes: UseEventBusEventsSubscribes<DataGridStoreColumnEvents>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridColumnEvents: <Item extends DataGridItem, AccessorReturn>(column: DataGridColumn<Item, AccessorReturn>, subscribes: UseEventBusEventsSubscribes<DataGridStoreColumnEvents>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/column/hooks/useDataGridColumnsInfo.d.ts

@@ -1,2 +1,3 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
-export declare const useDataGridColumnsInfo: <Item extends unknown>(store?: DataGridStore<Item>) => import("..").DataGridColumnsInfo<Item, unknown>;
+export declare const useDataGridColumnsInfo: <Item extends DataGridItem>(store?: DataGridStore<Item>) => import("..").DataGridColumnsInfo<Item, unknown>;

package/__inner__/types/core/column/store/DataGridStoreColumn.d.ts

@@ -1,3 +1,4 @@
+import type { ReactNode } from 'react';
 import { EventBus } from '../../../shared';
 import type { DataGridStoreColumnsGroup } from '../../columns-group';
 import type { DataGridItem, DataGridColumnCell, DataGridColumnHeader, DataGridColumnAccessor, DataGridColumnFooter } from '../../entities';
@@ -8,7 +9,7 @@ import type { DataGridStoreColumnEvents, DataGridStoreColumnWidth } from './type
 export declare class DataGridStoreColumn<Item extends DataGridItem, AccessorReturn = unknown> {
     id: string;
     cell: DataGridColumnCell<Item, AccessorReturn>;
-    name: string;
+    name: () => ReactNode;
     header: DataGridColumnHeader;
     align: DataGridColumnAlign;
     accessor: DataGridColumnAccessor<Item, AccessorReturn>;

package/__inner__/types/core/column/store/utils.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { DataGridItem } from '../../entities';
+import type { DataGridColumn } from '../table';
+import type { DataGridStoreColumn } from './DataGridStoreColumn';
+export declare const createDataGridStoreColumnName: <Item extends DataGridItem, AccessorReturn = unknown>(column: DataGridColumn<Item, AccessorReturn>, storeColumn: DataGridStoreColumn<Item, AccessorReturn>) => () => string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;

package/__inner__/types/core/column/table/DataGridColumn.d.ts

@@ -1,30 +1,20 @@
 import type { DataGridColumnsGroup } from '../../columns-group';
 import type { DataGridColumnAccessor, DataGridColumnCell, DataGridColumnFooter, DataGridColumnHeader, DataGridItem } from '../../entities';
-import type { DataGridFilterOption, DataGridAutocompleteTableFilterParams, DataGridAutocompleteListCardTableFilterParams, DataGridDateTableFilterParams, DataGridNumberTableFilterParams, DataGridStringTableFilterParams, DataGridSelectTableFilterParams } from '../../filter';
-import type { DataGridTable } from '../../table';
 import type { DataGridColumnAlign, DataGridColumnSortSettings, DataGridColumnWidth, DataGridGetColumnWidth } from '../entities';
-import type { DataGridColumnParams } from './types';
+import type { DataGridColumnName, DataGridColumnParams } from './types';
 export declare class DataGridColumn<Item extends DataGridItem, AccessorReturn = unknown> {
     rawId: string;
     header: DataGridColumnHeader;
-    name: string;
+    name: DataGridColumnName<Item, AccessorReturn>;
     cell: DataGridColumnCell<Item, AccessorReturn>;
     align: DataGridColumnAlign;
     footer: DataGridColumnFooter | undefined;
     accessor: DataGridColumnAccessor<Item, AccessorReturn>;
     root: DataGridColumnsGroup<Item> | null;
-    private context;
     sortSettings: DataGridColumnSortSettings;
     width: DataGridColumnWidth | DataGridGetColumnWidth<Item, AccessorReturn> | null;
     constructor({ id, cell, header, accessor, footer, name, align, sorting, width, }: DataGridColumnParams<Item, AccessorReturn>);
-    setContext(context: DataGridTable<Item>): void;
     get id(): string;
     setRoot(root: DataGridColumnsGroup<Item>): void;
-    createDateFilter(params: DataGridDateTableFilterParams<Item>): import("../../filter").DataGridDateTableFilter<Item>;
-    createSelectFilter<Option extends DataGridFilterOption>(params: DataGridSelectTableFilterParams<Item, Option>): import("../../filter").DataGridSelectTableFilter<Item, Option>;
-    createNumberFilter(params: DataGridNumberTableFilterParams<Item>): import("../../filter").DataGridNumberTableFilter<Item>;
-    createStringFilter(params: DataGridStringTableFilterParams<Item>): import("../../filter").DataGridStringTableFilter<Item>;
-    createAutocompleteFilter<Option extends DataGridFilterOption>(params: DataGridAutocompleteTableFilterParams<Item, Option>): import("../../filter").DataGridAutocompleteTableFilter<Item, Option>;
-    createAutocompleteListCardFilter<Option extends DataGridFilterOption>(params: DataGridAutocompleteListCardTableFilterParams<Item, Option>): import("../../filter").DataGridAutocompleteListCardTableFilter<Item, Option>;
     get depth(): number;
 }

package/__inner__/types/core/column/table/types.d.ts

@@ -1,9 +1,15 @@
+import type { ReactNode } from 'react';
 import type { DataGridColumnAccessor, DataGridColumnCell, DataGridColumnFooter, DataGridColumnHeader, DataGridItem } from '../../entities';
 import type { DataGridColumnAlign, DataGridColumnWidth, DataGridGetColumnWidth } from '../entities';
+import type { DataGridStoreColumn } from '../store';
+export type DataGridColumnNameRender<Item extends DataGridItem, AccessorReturn> = (params: {
+    column: DataGridStoreColumn<Item, AccessorReturn>;
+}) => ReactNode;
+export type DataGridColumnName<Item extends DataGridItem, AccessorReturn> = ReactNode | DataGridColumnNameRender<Item, AccessorReturn>;
 export type DataGridColumnParams<Item extends DataGridItem, AccessorReturn> = {
     id: string;
     accessor: DataGridColumnAccessor<Item, AccessorReturn>;
-    name: string;
+    name: DataGridColumnName<Item, AccessorReturn>;
     header?: DataGridColumnHeader;
     cell?: DataGridColumnCell<Item, AccessorReturn>;
     footer?: DataGridColumnFooter;

package/__inner__/types/core/column/table/utils.d.ts

@@ -0,0 +1,2 @@
+import type { DataGridItem } from '../../entities';
+export declare const createDataGridColumnDefaultRender: <Item extends DataGridItem, AccessorReturn = unknown>() => import("../../entities").DataGridColumnCellRender<Item, AccessorReturn>;

package/__inner__/types/core/columns-group/hooks/useDataGridColumnsGroup.d.ts

@@ -1,3 +1,4 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridColumnsGroup } from '../table';
-export declare const useDataGridColumnsGroup: <Item extends unknown>(group: DataGridColumnsGroup<Item>, store?: DataGridStore<Item>) => import("..").DataGridStoreColumnsGroup<Item>;
+export declare const useDataGridColumnsGroup: <Item extends DataGridItem>(group: DataGridColumnsGroup<Item>, store?: DataGridStore<Item>) => import("..").DataGridStoreColumnsGroup<Item>;

package/__inner__/types/core/columns-group/hooks/useDataGridColumnsGroupEvents.d.ts

@@ -1,5 +1,6 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStoreColumnsGroupEvents } from '../store';
 import type { DataGridColumnsGroup } from '../table';
-export declare const useDataGridColumnsGroupEvents: <Item extends unknown>(group: DataGridColumnsGroup<Item>, subscribes: UseEventBusEventsSubscribes<DataGridStoreColumnsGroupEvents<Item>>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridColumnsGroupEvents: <Item extends DataGridItem>(group: DataGridColumnsGroup<Item>, subscribes: UseEventBusEventsSubscribes<DataGridStoreColumnsGroupEvents<Item>>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/entities/cell.d.ts

@@ -1,5 +1,11 @@
 import type { ReactNode } from 'react';
+import type { DataGridStoreColumn } from '../column';
 import type { DataGridItem } from './data';
-export type DataGridColumnCellRender<Item extends DataGridItem, AccessorReturn> = (data: AccessorReturn, item: Item, index: number) => ReactNode;
+export type DataGridColumnCellRender<Item extends DataGridItem, AccessorReturn> = (params: {
+    data: AccessorReturn;
+    item: Item;
+    index: number;
+    column: DataGridStoreColumn<Item, AccessorReturn>;
+}) => ReactNode;
 export type DataGridColumnCellNode = ReactNode;
 export type DataGridColumnCell<Item extends DataGridItem, AccessorReturn> = DataGridColumnCellNode | DataGridColumnCellRender<Item, AccessorReturn>;

package/__inner__/types/core/filter/hooks/useDataGridFilter.d.ts

@@ -1,3 +1,4 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridTableFilter } from '../table/base';
-export declare const useDataGridFilter: <Item extends unknown, Filter extends DataGridTableFilter<Item>>(filter: Filter, store?: DataGridStore<Item>) => import("../../store").DataGridTableFilterToStore<Item, Filter>;
+export declare const useDataGridFilter: <Item extends DataGridItem, Filter extends DataGridTableFilter<Item>>(filter: Filter, store?: DataGridStore<Item>) => import("../../store").DataGridTableFilterToStore<Item, Filter>;

package/__inner__/types/core/filter/hooks/useDataGridFilterEvents.d.ts

@@ -1,5 +1,6 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore, DataGridTableFilterToStore } from '../../store';
 import type { DataGridTableFilter } from '../table';
 import type { DataGridStoreFilterExtractEvents } from '../types';
-export declare const useDataGridFilterEvents: <Item extends unknown, Filter extends DataGridTableFilter<Item>>(filter: Filter, subscribes: UseEventBusEventsSubscribes<DataGridStoreFilterExtractEvents<DataGridTableFilterToStore<Item, Filter>>>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridFilterEvents: <Item extends DataGridItem, Filter extends DataGridTableFilter<Item>>(filter: Filter, subscribes: UseEventBusEventsSubscribes<DataGridStoreFilterExtractEvents<DataGridTableFilterToStore<Item, Filter>>>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/filter/hooks/useDataGridFilters.d.ts

@@ -1,2 +1,3 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
-export declare const useDataGridFilters: <Item extends unknown>(store?: DataGridStore<Item>) => import("..").DataGridStoreFilters<Item>;
+export declare const useDataGridFilters: <Item extends DataGridItem>(store?: DataGridStore<Item>) => import("..").DataGridStoreFilters<Item>;

package/__inner__/types/core/filter/hooks/useDataGridFiltersEvents.d.ts

@@ -1,4 +1,5 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStoreFiltersEvents } from '../store/types';
-export declare const useDataGridFiltersEvents: <Item extends unknown>(subscribes: UseEventBusEventsSubscribes<DataGridStoreFiltersEvents<Item>>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridFiltersEvents: <Item extends DataGridItem>(subscribes: UseEventBusEventsSubscribes<DataGridStoreFiltersEvents<Item>>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/filter/store/base/DataGridStoreFilter.d.ts

@@ -1,5 +1,4 @@
 import { EventBus } from '../../../../shared';
-import type { DataGridStoreColumn } from '../../../column';
 import type { DataGridItem } from '../../../entities';
 import type { DataGridStore } from '../../../store';
 import type { DataGridFilterGroup } from '../../entities';
@@ -9,7 +8,6 @@ export declare abstract class DataGridStoreFilter<Item extends DataGridItem, Val
     id: string;
     protected rawName: string | null;
     protected context: DataGridStore<Item>;
-    column: DataGridStoreColumn<Item> | null;
     group: DataGridFilterGroup;
     abstract value: Value;
     abstract localValue: Value;
@@ -31,7 +29,6 @@ export declare abstract class DataGridStoreFilter<Item extends DataGridItem, Val
     setValueByType(value: Value, type: DataGridStoreFilterValueType): void;
     valueByType(type: DataGridStoreFilterValueType): Value;
     setGroup(group: DataGridFilterGroup): void;
-    setColumn(column: DataGridStoreColumn<Item>): void;
     get isEditedLocal(): boolean;
     get isEditedAllFilter(): boolean;
     abstract isEqualValues(value1: Value, value2: Value): boolean;

package/__inner__/types/core/filter/table/base/DataGridTableFilter.d.ts

@@ -1,12 +1,10 @@
-import type { DataGridColumn } from '../../../column';
 import type { DataGridItem } from '../../../entities';
 import type { DataGridFilterGroup } from '../../entities';
 import type { DataGridTableFilterParams, DataGridTableFilterRender } from './types';
 export declare abstract class DataGridTableFilter<Item extends DataGridItem, Render extends DataGridTableFilterRender<Item, any> = DataGridTableFilterRender<Item, any>> {
     id: string;
     name: string | null;
-    readonly column: DataGridColumn<Item> | null;
     group: DataGridFilterGroup;
     render: Render | null;
-    constructor({ id, column, name, group, render, }: DataGridTableFilterParams<Item, Render>);
+    constructor({ id, name, group, render, }: DataGridTableFilterParams<Item, Render>);
 }

package/__inner__/types/core/filter/table/base/types.d.ts

@@ -1,5 +1,4 @@
 import type { ReactNode } from 'react';
-import type { DataGridColumn } from '../../../column';
 import type { DataGridItem } from '../../../entities';
 import type { DataGridStore } from '../../../store';
 import type { DataGridFilterGroup } from '../../entities';
@@ -13,6 +12,5 @@ export type DataGridTableFilterParams<Item extends DataGridItem, Render extends
     id: string;
     group?: DataGridFilterGroup;
     name?: string;
-    column?: DataGridColumn<Item>;
     render?: Render;
 };

package/__inner__/types/core/pagination/hooks/useDataGridPagination.d.ts

@@ -1,2 +1,3 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
-export declare const useDataGridPagination: <Item extends unknown>(store?: DataGridStore<Item>) => import("..").DataGridStorePagination<Item>;
+export declare const useDataGridPagination: <Item extends DataGridItem>(store?: DataGridStore<Item>) => import("..").DataGridStorePagination<Item>;

package/__inner__/types/core/pagination/hooks/useDataGridPaginationEvents.d.ts

@@ -1,4 +1,5 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStorePaginationEvents } from '../store';
-export declare const useDataGridPaginationEvents: <Item extends unknown>(subscribes: UseEventBusEventsSubscribes<DataGridStorePaginationEvents>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridPaginationEvents: <Item extends DataGridItem>(subscribes: UseEventBusEventsSubscribes<DataGridStorePaginationEvents>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/selection/hooks/useDataGridSelection.d.ts

@@ -1,2 +1,3 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
-export declare const useDataGridSelection: <Item extends unknown>(store?: DataGridStore<Item>) => import("..").DataGridStoreSelection<Item>;
+export declare const useDataGridSelection: <Item extends DataGridItem>(store?: DataGridStore<Item>) => import("..").DataGridStoreSelection<Item>;

package/__inner__/types/core/selection/hooks/useDataGridSelectionEvents.d.ts

@@ -1,4 +1,5 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStoreSelectionEvents } from '../store';
-export declare const useDataGridSelectionEvents: <Item extends unknown>(subscribes: UseEventBusEventsSubscribes<DataGridStoreSelectionEvents>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridSelectionEvents: <Item extends DataGridItem>(subscribes: UseEventBusEventsSubscribes<DataGridStoreSelectionEvents>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/store/hooks/useDataGridCreateStore.d.ts

@@ -1,4 +1,4 @@
-import type { DataGridData } from '../../entities';
+import type { DataGridData, DataGridItem } from '../../entities';
 import type { DataGridTable } from '../../table';
 import { DataGridStore } from '../DataGridStore';
-export declare const useDataGridCreateStore: <Item extends unknown>(table: DataGridTable<Item>, data: DataGridData<Item>, onCreate?: (store: DataGridStore<Item>) => void) => DataGridStore<Item>;
+export declare const useDataGridCreateStore: <Item extends DataGridItem>(table: DataGridTable<Item>, data: DataGridData<Item>, onCreate?: (store: DataGridStore<Item>) => void) => DataGridStore<Item>;

package/__inner__/types/core/store/hooks/useDataGridStore.d.ts

@@ -1 +1,2 @@
-export declare const useDataGridStore: <Item extends unknown>() => import("..").DataGridStore<Item>;
+import type { DataGridItem } from '../../entities';
+export declare const useDataGridStore: <Item extends DataGridItem>() => import("..").DataGridStore<Item>;

package/__inner__/types/core/store/hooks/useDataGridStoreEvents.d.ts

@@ -1,4 +1,5 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../DataGridStore';
 import type { DataGridStoreEvents } from '../entities';
-export declare const useDataGridStoreEvents: <Item extends unknown>(subscribes: UseEventBusEventsSubscribes<DataGridStoreEvents<Item>>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridStoreEvents: <Item extends DataGridItem>(subscribes: UseEventBusEventsSubscribes<DataGridStoreEvents<Item>>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/sub-row/entities/index.d.ts

@@ -1,2 +1,3 @@
 export * from './position';
+export * from './render';
 export * from './settings';

package/__inner__/types/core/sub-row/entities/render.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { DataGridItem } from '../../entities';
+import type { DataGridStoreSubRow } from '../store/sub-row';
+export type DataGridSubRowRender<Item extends DataGridItem> = (params: {
+    item: Item;
+    index: number;
+    subRow: DataGridStoreSubRow<Item>;
+}) => ReactNode;

package/__inner__/types/core/sub-row/hooks/useDataGridSubRow.d.ts

@@ -1,3 +1,4 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridSubRow } from '../table';
-export declare const useDataGridSubRow: <Item extends unknown>(subRow: DataGridSubRow<Item>, store?: DataGridStore<Item>) => import("..").DataGridStoreSubRow<Item>;
+export declare const useDataGridSubRow: <Item extends DataGridItem>(subRow: DataGridSubRow<Item>, store?: DataGridStore<Item>) => import("..").DataGridStoreSubRow<Item>;

package/__inner__/types/core/sub-row/hooks/useDataGridSubRowEvents.d.ts

@@ -1,5 +1,6 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStoreSubRowEvents } from '../store';
 import type { DataGridSubRow } from '../table';
-export declare const useDataGridSubRowEvents: <Item extends unknown>(subRow: DataGridSubRow<Item>, subscribes: UseEventBusEventsSubscribes<DataGridStoreSubRowEvents<Item>>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridSubRowEvents: <Item extends DataGridItem>(subRow: DataGridSubRow<Item>, subscribes: UseEventBusEventsSubscribes<DataGridStoreSubRowEvents<Item>>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/sub-row/hooks/useDataGridSubRows.d.ts

@@ -1,2 +1,3 @@
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
-export declare const useDataGridSubRows: <Item extends unknown>(store?: DataGridStore<Item>) => import("..").DataGridStoreSubRows<Item>;
+export declare const useDataGridSubRows: <Item extends DataGridItem>(store?: DataGridStore<Item>) => import("..").DataGridStoreSubRows<Item>;

package/__inner__/types/core/sub-row/hooks/useDataGridSubRowsEvents.d.ts

@@ -1,4 +1,5 @@
 import type { UseEventBusEventsSubscribes } from '../../../shared';
+import type { DataGridItem } from '../../entities';
 import type { DataGridStore } from '../../store';
 import type { DataGridStoreSubRowsEvents } from '../store';
-export declare const useDataGridSubRowsEvents: <Item extends unknown>(subscribes: UseEventBusEventsSubscribes<DataGridStoreSubRowsEvents<Item>>, store?: DataGridStore<Item>) => void;
+export declare const useDataGridSubRowsEvents: <Item extends DataGridItem>(subscribes: UseEventBusEventsSubscribes<DataGridStoreSubRowsEvents<Item>>, store?: DataGridStore<Item>) => void;

package/__inner__/types/core/sub-row/store/sub-row/DataGridStoreSubRow.d.ts

@@ -1,7 +1,7 @@
-import type { ReactNode } from 'react';
 import { EventBus } from '../../../../shared';
 import type { DataGridItem } from '../../../entities';
 import type { DataGridStore } from '../../../store';
+import type { DataGridSubRowRender } from '../../entities';
 import type { DataGridSubRow } from '../../table';
 import type { DataGridStoreSubRowEvents } from './types';
 export declare class DataGridStoreSubRow<Item extends DataGridItem> {
@@ -9,7 +9,7 @@ export declare class DataGridStoreSubRow<Item extends DataGridItem> {
     root: DataGridStoreSubRow<Item> | null;
     rows: DataGridStoreSubRow<Item>[];
     expandedByRowId: Record<string, boolean>;
-    render: (item: Item, index: number) => ReactNode;
+    render: DataGridSubRowRender<Item>;
     context: DataGridStore<Item>;
     eventBus: EventBus<DataGridStoreSubRowEvents<Item>>;
     private readonly getIsVisible;

package/__inner__/types/core/sub-row/table/DataGridSubRow.d.ts

@@ -1,11 +1,11 @@
-import type { ReactNode } from 'react';
 import type { DataGridItem } from '../../entities';
+import type { DataGridSubRowRender } from '../entities';
 import type { DataGridSubRowParams } from './types';
 export declare class DataGridSubRow<Item extends DataGridItem> {
     rawId: string;
     root: DataGridSubRow<Item> | null;
     subRows: DataGridSubRow<Item>[];
-    render: (item: Item, index: number) => ReactNode;
+    render: DataGridSubRowRender<Item>;
     isVisible: (item: Item, index: number) => boolean;
     constructor({ id, render, isVisible }: DataGridSubRowParams<Item>);
     get id(): string;

package/__inner__/types/core/sub-row/table/types.d.ts

@@ -1,7 +1,7 @@
-import type { ReactNode } from 'react';
 import type { DataGridItem } from '../../entities';
+import type { DataGridSubRowRender } from '../entities';
 export type DataGridSubRowParams<Item extends DataGridItem> = {
     id: string;
-    render: (item: Item, index: number) => ReactNode;
+    render: DataGridSubRowRender<Item>;
     isVisible?: (item: Item, index: number) => boolean;
 };

package/__inner__/types/ui/DataGrid/DataGrid.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { DataGridItem } from '../../core';
 import type { DataGridProps } from './types';
 import './components/DataGridWrapper/DataGridWrapper.css';
 import './components/DataGridPagination/DataGridPagination.css';
@@ -20,4 +21,4 @@ import '../footer/DataGridFooterContainer/DataGridFooterContainer.css';
 import '../footer/DataGridSelectionFooter/DataGridSelectionFooter.css';
 import './DataGrid.css';
 export declare const cnDataGrid: import("@bem-react/classname").ClassNameFormatter;
-export declare const DataGrid: <Item extends unknown>({ store, actions, layout, subControlsBefore, subControlsAfter, className, allFiltersDrawer, settingsDrawer, paginationBeforeText, paginationAfterText, stickyHeader, loading, empty, clearFiltersText, applyFiltersText, footer, overflow, refs, }: DataGridProps<Item>) => React.JSX.Element;
+export declare const DataGrid: <Item extends DataGridItem>({ store, actions, layout, subControlsBefore, subControlsAfter, className, allFiltersDrawer, settingsDrawer, paginationBeforeText, paginationAfterText, stickyHeader, loading, empty, clearFiltersText, applyFiltersText, footer, overflow, refs, }: DataGridProps<Item>) => React.JSX.Element;

package/__inner__/types/ui/DataGrid/components/DataGridPagination/entities/afterText.d.ts

@@ -1,2 +1,4 @@
 import type { ReactNode } from 'react';
-export type DataGridPaginationAfterText = ReactNode | ((total: number) => ReactNode);
+export type DataGridPaginationAfterText = ReactNode | ((params: {
+    total: number;
+}) => ReactNode);

package/__inner__/types/ui/DataGridAllFiltersDrawer/DataGridAllFiltersDrawer.d.ts

@@ -1,5 +1,17 @@
 import React from 'react';
-import type { DataGridAllFiltersDrawerProps } from './types';
-export declare const DataGridAllFiltersDrawer: (({ title, subTitle, applyButton, closeButton, }: DataGridAllFiltersDrawerProps) => React.JSX.Element) & {
-    displayName: string;
-};
+export declare const DataGridAllFiltersDrawer: React.MemoExoticComponent<React.ForwardRefExoticComponent<(Omit<{
+    title: string;
+    subTitle?: string;
+    closeButton: string;
+    applyButton: string;
+} & Omit<import("@ozen-ui/kit/DrawerNext").DrawerDeviceTypeProps<"mobile">, "children" | "open"> & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<{
+    title: string;
+    subTitle?: string;
+    closeButton: string;
+    applyButton: string;
+} & Omit<import("@ozen-ui/kit/DrawerNext").DrawerDeviceTypeProps<"desktop">, "children" | "open"> & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<{
+    title: string;
+    subTitle?: string;
+    closeButton: string;
+    applyButton: string;
+} & Omit<import("@ozen-ui/kit/DrawerNext").DrawerDeviceTypeProps<undefined>, "children" | "open"> & React.RefAttributes<HTMLDivElement>, "ref">) & React.RefAttributes<HTMLDivElement>>>;

package/__inner__/types/ui/DataGridAllFiltersDrawer/types.d.ts

@@ -1,6 +1,8 @@
+import type { DrawerRef, DrawerOmittedProps } from "@ozen-ui/kit/DrawerNext";
+export type DataGridAllFiltersDrawerRef = DrawerRef;
 export type DataGridAllFiltersDrawerProps = {
     title: string;
     subTitle?: string;
     closeButton: string;
     applyButton: string;
-};
+} & DrawerOmittedProps<'children' | 'open'>;

package/__inner__/types/ui/DataGridSettingsDrawer/DataGridSettingsDrawer.d.ts

@@ -1,5 +1,23 @@
 import React from 'react';
-import type { DataGridSettingsDrawerProps } from './types';
-export declare const DataGridSettingsDrawer: (({ title, subTitle, closeButton, applyButton, }: DataGridSettingsDrawerProps) => React.JSX.Element) & {
-    displayName: string;
-};
+export declare const DataGridSettingsDrawer: React.MemoExoticComponent<React.ForwardRefExoticComponent<(Omit<{
+    title: string;
+    subTitle?: string;
+    closeButton: string;
+    applyButton: string;
+    open?: never;
+    children?: never;
+} & Omit<import("@ozen-ui/kit/DrawerNext").DrawerDeviceTypeProps<"mobile">, "children" | "open"> & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<{
+    title: string;
+    subTitle?: string;
+    closeButton: string;
+    applyButton: string;
+    open?: never;
+    children?: never;
+} & Omit<import("@ozen-ui/kit/DrawerNext").DrawerDeviceTypeProps<"desktop">, "children" | "open"> & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<{
+    title: string;
+    subTitle?: string;
+    closeButton: string;
+    applyButton: string;
+    open?: never;
+    children?: never;
+} & Omit<import("@ozen-ui/kit/DrawerNext").DrawerDeviceTypeProps<undefined>, "children" | "open"> & React.RefAttributes<HTMLDivElement>, "ref">) & React.RefAttributes<HTMLDivElement>>>;

package/__inner__/types/ui/DataGridSettingsDrawer/types.d.ts

@@ -1,6 +1,10 @@
+import type { DrawerOmittedProps, DrawerRef } from "@ozen-ui/kit/DrawerNext";
+export type DataGridSettingsDrawerRef = DrawerRef;
 export type DataGridSettingsDrawerProps = {
     title: string;
     subTitle?: string;
     closeButton: string;
     applyButton: string;
-};
+    open?: never;
+    children?: never;
+} & DrawerOmittedProps<'children' | 'open'>;