@ozen-ui/data-grid 0.73.0

package/__inner__/esm/ui/filters/DataGridStringFilter/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+export * from './DataGridAutocompleteFilter';
+export * from './DataGridAutocompleteListCardFilter';
+export * from './DataGridCustomFilter';
+export * from './DataGridDateFilter';
+export * from './DataGridFilter';
+export * from './DataGridNumberFilter';
+export * from './DataGridSelectFilter';
+export * from './DataGridStringFilter';

package/__inner__/esm/ui/footer/DataGridFooterContainer/DataGridFooterContainer.css

@@ -0,0 +1,8 @@
+.DataGridFooterContainer {
+  position: sticky;
+  inline-size: 100%;
+  inset-block-end: 0;
+  inset-inline-start: 0;
+  background-color: var(--color-background-main);
+  border-block-start: var(--border-width-s) solid var(--color-border-secondary);
+}

package/__inner__/esm/ui/footer/DataGridFooterContainer/DataGridFooterContainer.js

@@ -0,0 +1,14 @@
+import { __assign, __rest } from "tslib";
+import React from 'react';
+import { polymorphicComponentWithRef } from '@ozen-ui/kit/utils';
+import { cn } from '../../../shared';
+import { DATA_GRID_FOOTER_CONTAINER_DEFAULT_TAG } from './constants';
+export var cnDataGridFooterContainer = cn('DataGridFooterContainer');
+export var DataGridFooterContainer = polymorphicComponentWithRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, _b = _a.as, Tag = _b === void 0 ? DATA_GRID_FOOTER_CONTAINER_DEFAULT_TAG : _b, other = __rest(_a, ["children", "className", "as"]);
+    if (!children) {
+        return null;
+    }
+    return (React.createElement(Tag, __assign({}, other, { ref: ref, className: cnDataGridFooterContainer('', [className]) }), children));
+});
+DataGridFooterContainer.displayName = 'DataGridFooterContainer';

package/__inner__/esm/ui/footer/DataGridFooterContainer/constants.js

@@ -0,0 +1 @@
+export var DATA_GRID_FOOTER_CONTAINER_DEFAULT_TAG = 'div';

package/__inner__/esm/ui/footer/DataGridFooterContainer/index.js

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './DataGridFooterContainer';
+export * from './types';

package/__inner__/esm/ui/footer/DataGridFooterContainer/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/ui/footer/DataGridSelectionFooter/DataGridSelectionFooter.css

@@ -0,0 +1,11 @@
+/* stylelint-disable */
+.DataGridSelectionFooter {
+  font: var(--typography-text-s-font);
+  letter-spacing: var(--typography-text-s-letter_spacing, 0);
+  text-transform: var(--typography-text-s-text_transform, none);
+  color: var(--color-content-primary);
+  padding: var(--spacing-s);
+}
+.DataGridSelectionFooter-Divider {
+    height: 1em;
+  }

package/__inner__/esm/ui/footer/DataGridSelectionFooter/DataGridSelectionFooter.js

@@ -0,0 +1,23 @@
+import { __assign, __rest } from "tslib";
+import React from 'react';
+import { Divider } from "@ozen-ui/kit/Divider";
+import { Stack } from "@ozen-ui/kit/Stack";
+import { useDataGridSelection, dataGridObserver } from '../../../core';
+import { cn } from '../../../shared';
+import { DataGridFooterContainer } from '../DataGridFooterContainer';
+export var cnDataGridSelectionFooter = cn('DataGridSelectionFooter');
+export var DataGridSelectionFooter = dataGridObserver(function (_a) {
+    var children = _a.children, className = _a.className, text = _a.text, other = __rest(_a, ["children", "className", "text"]);
+    var selection = useDataGridSelection();
+    var isWithSelection = selection.isEnabled;
+    if (!isWithSelection || selection.isSingle) {
+        return null;
+    }
+    return (React.createElement(DataGridFooterContainer, null,
+        React.createElement(Stack, __assign({}, other, { className: cnDataGridSelectionFooter('', [className]), gap: "l", align: "center", divider: React.createElement(Divider, { className: cnDataGridSelectionFooter('Divider'), orientation: "vertical" }) }),
+            React.createElement("span", null,
+                text,
+                ": ",
+                selection.selectedCount),
+            children && (React.createElement("div", { className: cnDataGridSelectionFooter('Content') }, children)))));
+});

package/__inner__/esm/ui/footer/DataGridSelectionFooter/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridSelectionFooter';
+export * from './types';

package/__inner__/esm/ui/footer/DataGridSelectionFooter/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/ui/footer/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridFooterContainer';
+export * from './DataGridSelectionFooter';

package/__inner__/esm/ui/index.js

@@ -0,0 +1,10 @@
+export * from './actions';
+export * from './cells';
+export * from './context';
+export * from './DataGrid';
+export * from './DataGridAllFiltersDrawer';
+export * from './footer';
+export * from './DataGridSettingsDrawer';
+export * from './filters';
+export * from './statuses';
+export * from './sub-controls';

package/__inner__/esm/ui/statuses/DataGridEmpty/DataGridEmpty.js

@@ -0,0 +1,12 @@
+import { __assign, __rest } from "tslib";
+import React from 'react';
+import { dataGridObserver, useDataGridStore } from '../../../core';
+import { DataGridPlaceholder } from '../DataGridPlaceholder';
+export var DataGridEmpty = dataGridObserver(function (_a) {
+    var children = _a.children, other = __rest(_a, ["children"]);
+    var store = useDataGridStore();
+    if (!store.isEmpty) {
+        return null;
+    }
+    return React.createElement(DataGridPlaceholder, __assign({}, other), children);
+});

package/__inner__/esm/ui/statuses/DataGridEmpty/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridEmpty';
+export * from './types';

package/__inner__/esm/ui/statuses/DataGridEmpty/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/ui/statuses/DataGridLoading/DataGridLoading.js

@@ -0,0 +1,18 @@
+import { __assign, __rest } from "tslib";
+import React from 'react';
+import { Loader } from "@ozen-ui/kit/Loader";
+import { Stack } from "@ozen-ui/kit/Stack";
+import { Typography } from "@ozen-ui/kit/Typography";
+import { dataGridObserver, useDataGridStore } from '../../../core';
+import { DataGridPlaceholder } from '../DataGridPlaceholder';
+export var DataGridLoading = dataGridObserver(function (_a) {
+    var children = _a.children, other = __rest(_a, ["children"]);
+    var store = useDataGridStore();
+    if (!store.isLoading) {
+        return null;
+    }
+    return (React.createElement(DataGridPlaceholder, __assign({}, other),
+        React.createElement(Stack, { justify: "center", direction: "column", align: "center", gap: "s" },
+            React.createElement(Loader, null),
+            React.createElement(Typography, null, children))));
+});

package/__inner__/esm/ui/statuses/DataGridLoading/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridLoading';
+export * from './types';

package/__inner__/esm/ui/statuses/DataGridLoading/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/ui/statuses/DataGridPlaceholder/DataGridPlaceholder.css

@@ -0,0 +1,16 @@
+.DataGridPlaceholder {
+  block-size: 100%;
+}
+
+  .DataGridPlaceholder-CellWrapper {
+    block-size: 100%;
+  }
+
+  .DataGridPlaceholder-Cell {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    block-size: 100%;
+    padding: var(--spacing-xs);
+    box-sizing: border-box;
+  }

package/__inner__/esm/ui/statuses/DataGridPlaceholder/DataGridPlaceholder.js

@@ -0,0 +1,13 @@
+import React from 'react';
+import { TableRow } from "@ozen-ui/kit/Table";
+import { dataGridObserver, useDataGridStore } from '../../../core';
+import { cn } from '../../../shared';
+import { DataGridCell } from '../../DataGrid/components';
+export var cnDataGridPlaceholder = cn('DataGridPlaceholder');
+export var DataGridPlaceholder = dataGridObserver(function (_a) {
+    var children = _a.children, className = _a.className;
+    var store = useDataGridStore();
+    return (React.createElement(TableRow, { className: cnDataGridPlaceholder('', [className]) },
+        React.createElement(DataGridCell, { colSpan: store.colSpan, className: cnDataGridPlaceholder('CellWrapper') },
+            React.createElement("div", { className: cnDataGridPlaceholder('Cell') }, children))));
+});

package/__inner__/esm/ui/statuses/DataGridPlaceholder/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridPlaceholder';
+export * from './types';

package/__inner__/esm/ui/statuses/DataGridPlaceholder/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/ui/statuses/index.js

@@ -0,0 +1,3 @@
+export * from './DataGridEmpty';
+export * from './DataGridLoading';
+export * from './DataGridPlaceholder';

package/__inner__/esm/ui/sub-controls/DataGridSubControlIconButton/DataGridSubControlIconButton.js

@@ -0,0 +1,9 @@
+import { __assign, __rest } from "tslib";
+import React from 'react';
+import { IconButton } from "@ozen-ui/kit/IconButtonNext";
+import { polymorphicComponentWithRef } from '@ozen-ui/kit/utils';
+import { DATA_GRID_SUB_CONTROL_ICON_BUTTON_DEFAULT_TAG } from './constants';
+export var DataGridSubControlIconButton = polymorphicComponentWithRef(function (_a, ref) {
+    var icon = _a.icon, _b = _a.as, as = _b === void 0 ? DATA_GRID_SUB_CONTROL_ICON_BUTTON_DEFAULT_TAG : _b, other = __rest(_a, ["icon", "as"]);
+    return (React.createElement(IconButton, __assign({}, other, { as: as, ref: ref, icon: icon, size: "xs" })));
+});

package/__inner__/esm/ui/sub-controls/DataGridSubControlIconButton/constants.js

@@ -0,0 +1,2 @@
+import { ICON_BUTTON_DEFAULT_TAG } from "@ozen-ui/kit/IconButtonNext";
+export var DATA_GRID_SUB_CONTROL_ICON_BUTTON_DEFAULT_TAG = ICON_BUTTON_DEFAULT_TAG;

package/__inner__/esm/ui/sub-controls/DataGridSubControlIconButton/index.js

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './DataGridSubControlIconButton';
+export * from './types';

package/__inner__/esm/ui/sub-controls/DataGridSubControlIconButton/types.js

@@ -0,0 +1 @@
+export {};

package/__inner__/esm/ui/sub-controls/index.js

@@ -0,0 +1 @@
+export * from './DataGridSubControlIconButton';

package/__inner__/types/core/column/entities/align.d.ts

@@ -0,0 +1,4 @@
+export declare const dataGridColumnAlign: readonly ["left", "right"];
+export type DataGridColumnAlign = (typeof dataGridColumnAlign)[number];
+export declare const dataGridColumnVerticalAlign: readonly ["baseline", "top", "middle", "bottom", "sub", "text-top"];
+export type DataGridColumnVerticalAlign = (typeof dataGridColumnVerticalAlign)[number];

package/__inner__/types/core/column/entities/columns-info.d.ts

@@ -0,0 +1,8 @@
+import type { DataGridItem } from '../../entities';
+import type { DataGridColumnVerticalAlign } from './align';
+import type { DataGridColumnWidth, DataGridGetColumnWidth } from './width';
+export type DataGridColumnsInfo<Item extends DataGridItem, AccessorReturn> = {
+    canHide: boolean;
+    width: DataGridColumnWidth | DataGridGetColumnWidth<Item, AccessorReturn>;
+    verticalAlign: DataGridColumnVerticalAlign;
+};

package/__inner__/types/core/column/entities/index.d.ts

@@ -0,0 +1,4 @@
+export * from './align';
+export * from './columns-info';
+export * from './sort';
+export * from './width';

package/__inner__/types/core/column/entities/sort.d.ts

@@ -0,0 +1,5 @@
+export declare const dataGridColumnSortType: readonly ["ascending", "descending"];
+export type DataGridColumnSortType = (typeof dataGridColumnSortType)[number];
+export type DataGridColumnSortSettings = {
+    available: DataGridColumnSortType[] | null;
+};

package/__inner__/types/core/column/entities/width.d.ts

@@ -0,0 +1,6 @@
+import type { CSSUnit } from '../../../shared';
+import type { DataGridItem } from '../../entities';
+import type { DataGridStore } from '../../store';
+import type { DataGridStoreColumn } from '../store';
+export type DataGridColumnWidth = `${number}${CSSUnit}` | number | 'responsive';
+export type DataGridGetColumnWidth<Item extends DataGridItem, AccessorReturn> = (column: DataGridStoreColumn<Item, AccessorReturn>, context: DataGridStore<Item>) => DataGridColumnWidth;

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

@@ -0,0 +1,3 @@
+export * from './useDataGridColumn';
+export * from './useDataGridColumnEvents';
+export * from './useDataGridColumnsInfo';

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

@@ -0,0 +1,3 @@
+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>;

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

@@ -0,0 +1,5 @@
+import type { UseEventBusEventsSubscribes } from '../../../shared';
+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;

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

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

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

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './hooks';
+export * from './store';
+export * from './table';

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

@@ -0,0 +1,41 @@
+import { EventBus } from '../../../shared';
+import type { DataGridStoreColumnsGroup } from '../../columns-group';
+import type { DataGridItem, DataGridColumnCell, DataGridColumnHeader, DataGridColumnAccessor, DataGridColumnFooter } from '../../entities';
+import type { DataGridStore } from '../../store';
+import type { DataGridColumnAlign, DataGridColumnSortSettings, DataGridColumnSortType } from '../entities';
+import type { DataGridColumn } from '../table';
+import type { DataGridStoreColumnEvents, DataGridStoreColumnWidth } from './types';
+export declare class DataGridStoreColumn<Item extends DataGridItem, AccessorReturn = unknown> {
+    id: string;
+    cell: DataGridColumnCell<Item, AccessorReturn>;
+    name: string;
+    header: DataGridColumnHeader;
+    align: DataGridColumnAlign;
+    accessor: DataGridColumnAccessor<Item, AccessorReturn>;
+    footer: DataGridColumnFooter | undefined;
+    root: DataGridStoreColumnsGroup<Item> | null;
+    context: DataGridStore<Item>;
+    sortSettings: DataGridColumnSortSettings;
+    sort: DataGridColumnSortType | null;
+    width: DataGridStoreColumnWidth;
+    eventBus: EventBus<DataGridStoreColumnEvents>;
+    private readonly rawWidth;
+    private rawIsVisible;
+    constructor(column: DataGridColumn<Item, AccessorReturn>, context: DataGridStore<Item>, root?: DataGridStoreColumnsGroup<Item>);
+    register(): void;
+    recalculate(): void;
+    setWidth(width: DataGridStoreColumnWidth): void;
+    setAlign(align: DataGridColumnAlign): void;
+    setSort(sort: DataGridColumnSortType | null): void;
+    setIsVisible(isVisible: boolean): void;
+    get hasSort(): boolean | null;
+    get isSortDisabled(): boolean;
+    switchSort(): void;
+    resetSort(): void;
+    get isAscending(): boolean;
+    get isDescending(): boolean;
+    get isSortActive(): boolean;
+    get isLeftAlign(): boolean;
+    get isRightAlign(): boolean;
+    get isVisible(): boolean;
+}

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

@@ -0,0 +1,2 @@
+export * from './DataGridStoreColumn';
+export * from './types';

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

@@ -0,0 +1,18 @@
+import type { CSSUnit } from '../../../shared';
+import type { DataGridColumnAlign, DataGridColumnSortType } from '../entities';
+export type DataGridStoreColumnWidth = `${number}${CSSUnit}` | 'responsive';
+export declare const dataGridStoreColumnEvent: {
+    readonly RECALCULATE: "recalculate";
+    readonly CHANGE_WIDTH: "changeWidth";
+    readonly CHANGE_SORT: "changeSort";
+    readonly CHANGE_IS_VISIBLE: "changeIsVisible";
+    readonly CHANGE_ALIGN: "changeAlign";
+};
+export type DataGridStoreColumnEvent = (typeof dataGridStoreColumnEvent)[keyof typeof dataGridStoreColumnEvent];
+export type DataGridStoreColumnEvents = {
+    [dataGridStoreColumnEvent.RECALCULATE]: null;
+    [dataGridStoreColumnEvent.CHANGE_WIDTH]: DataGridStoreColumnWidth;
+    [dataGridStoreColumnEvent.CHANGE_SORT]: DataGridColumnSortType | null;
+    [dataGridStoreColumnEvent.CHANGE_IS_VISIBLE]: boolean;
+    [dataGridStoreColumnEvent.CHANGE_ALIGN]: DataGridColumnAlign;
+};

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

@@ -0,0 +1,30 @@
+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';
+export declare class DataGridColumn<Item extends DataGridItem, AccessorReturn = unknown> {
+    rawId: string;
+    header: DataGridColumnHeader;
+    name: string;
+    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/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridColumn';
+export * from './types';

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

@@ -0,0 +1,13 @@
+import type { DataGridColumnAccessor, DataGridColumnCell, DataGridColumnFooter, DataGridColumnHeader, DataGridItem } from '../../entities';
+import type { DataGridColumnAlign, DataGridColumnWidth, DataGridGetColumnWidth } from '../entities';
+export type DataGridColumnParams<Item extends DataGridItem, AccessorReturn> = {
+    id: string;
+    accessor: DataGridColumnAccessor<Item, AccessorReturn>;
+    name: string;
+    header?: DataGridColumnHeader;
+    cell?: DataGridColumnCell<Item, AccessorReturn>;
+    footer?: DataGridColumnFooter;
+    align?: DataGridColumnAlign;
+    sorting?: boolean;
+    width?: DataGridColumnWidth | DataGridGetColumnWidth<Item, AccessorReturn>;
+};

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

@@ -0,0 +1,2 @@
+export * from './useDataGridColumnsGroup';
+export * from './useDataGridColumnsGroupEvents';

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

@@ -0,0 +1,3 @@
+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>;

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

@@ -0,0 +1,5 @@
+import type { UseEventBusEventsSubscribes } from '../../../shared';
+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;

package/__inner__/types/core/columns-group/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks';
+export * from './store';
+export * from './table';

package/__inner__/types/core/columns-group/store/DataGridStoreColumnsGroup.d.ts

@@ -0,0 +1,31 @@
+import { EventBus } from '../../../shared';
+import { DataGridStoreColumn } from '../../column';
+import type { DataGridColumnFooter, DataGridColumnHeader, DataGridItem } from '../../entities';
+import type { DataGridStore } from '../../store';
+import { DataGridColumnsGroup } from '../table';
+import type { DataGridStoreColumnsGroupEvents } from './types';
+export declare class DataGridStoreColumnsGroup<Item extends DataGridItem> {
+    id: string;
+    header: DataGridColumnHeader;
+    footer: DataGridColumnFooter | undefined;
+    depth: number;
+    nodes: (DataGridStoreColumn<Item> | DataGridStoreColumnsGroup<Item>)[];
+    root: DataGridStoreColumnsGroup<Item> | null;
+    topRoot: DataGridStoreColumnsGroup<Item>;
+    context: DataGridStore<Item>;
+    eventBus: EventBus<DataGridStoreColumnsGroupEvents<Item>>;
+    protected rawIsVisible: boolean;
+    constructor(group: DataGridColumnsGroup<Item>, context: DataGridStore<Item>, root?: DataGridStoreColumnsGroup<Item>, topRoot?: DataGridStoreColumnsGroup<Item>);
+    get columnsCount(): number;
+    get visibleColumnsCount(): number;
+    addColumn<AccessorReturn>(column: DataGridStoreColumn<Item, AccessorReturn>): DataGridStoreColumn<Item, AccessorReturn>;
+    addGroup(group: DataGridStoreColumnsGroup<Item>): DataGridStoreColumnsGroup<Item>;
+    setIsVisible(isVisible: boolean): void;
+    get isVisible(): boolean;
+    get visibleNodes(): (DataGridStoreColumnsGroup<Item> | DataGridStoreColumn<Item, unknown>)[];
+    getGroups(isVisibleOnly: boolean): DataGridStoreColumnsGroup<Item>[][];
+    get leftGroups(): DataGridStoreColumnsGroup<Item>[];
+    get offset(): number;
+    get columns(): DataGridStoreColumn<Item, unknown>[];
+    get visibleColumns(): DataGridStoreColumn<Item, unknown>[];
+}

package/__inner__/types/core/columns-group/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridStoreColumnsGroup';
+export * from './types';

package/__inner__/types/core/columns-group/store/types.d.ts

@@ -0,0 +1,14 @@
+import type { DataGridStoreColumn } from '../../column';
+import type { DataGridItem } from '../../entities';
+import type { DataGridStoreColumnsGroup } from './DataGridStoreColumnsGroup';
+export declare const dataGridStoreColumnsGroupEvent: {
+    readonly CHANGE_IS_VISIBLE: "changeIsVisible";
+    readonly ADD_COLUMN: "addColumn";
+    readonly ADD_GROUP: "addGroup";
+};
+export type DataGridStoreColumnsGroupEvent = (typeof dataGridStoreColumnsGroupEvent)[keyof typeof dataGridStoreColumnsGroupEvent];
+export type DataGridStoreColumnsGroupEvents<Item extends DataGridItem> = {
+    [dataGridStoreColumnsGroupEvent.CHANGE_IS_VISIBLE]: boolean;
+    [dataGridStoreColumnsGroupEvent.ADD_COLUMN]: DataGridStoreColumn<Item, unknown>;
+    [dataGridStoreColumnsGroupEvent.ADD_GROUP]: DataGridStoreColumnsGroup<Item>;
+};

package/__inner__/types/core/columns-group/table/DataGridColumnsGroup.d.ts

@@ -0,0 +1,19 @@
+import type { DataGridColumnParams } from '../../column';
+import { DataGridColumn } from '../../column';
+import type { DataGridColumnFooter, DataGridColumnHeader, DataGridItem } from '../../entities';
+import type { DataGridColumnsGroupParams } from './types';
+export declare class DataGridColumnsGroup<Item extends DataGridItem> {
+    rawId: string;
+    header: DataGridColumnHeader;
+    columns: (DataGridColumn<Item> | DataGridColumnsGroup<Item>)[];
+    footer: DataGridColumnFooter | undefined;
+    root: DataGridColumnsGroup<Item> | null;
+    constructor({ id, header, footer }: DataGridColumnsGroupParams);
+    get id(): string;
+    createColumn<AccessorReturn>(columnParams: DataGridColumnParams<Item, AccessorReturn>): DataGridColumn<Item, AccessorReturn>;
+    setRoot(root: DataGridColumnsGroup<Item>): void;
+    addColumn<AccessorReturn>(column: DataGridColumn<Item, AccessorReturn>): DataGridColumn<Item, AccessorReturn>;
+    createGroup(groupParams: DataGridColumnsGroupParams): DataGridColumnsGroup<Item>;
+    get depth(): number;
+    addGroup(group: DataGridColumnsGroup<Item>): DataGridColumnsGroup<Item>;
+}

package/__inner__/types/core/columns-group/table/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridColumnsGroup';
+export * from './types';

package/__inner__/types/core/columns-group/table/types.d.ts

@@ -0,0 +1,6 @@
+import type { DataGridColumnFooter, DataGridColumnHeader } from '../../entities';
+export type DataGridColumnsGroupParams = {
+    id: string;
+    header?: DataGridColumnHeader;
+    footer?: DataGridColumnFooter;
+};

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

@@ -0,0 +1,2 @@
+import type { DataGridItem } from './data';
+export type DataGridColumnAccessor<Item extends DataGridItem, AccessorReturn> = (item: Item, index: number) => AccessorReturn;

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

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

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

@@ -0,0 +1,2 @@
+export type DataGridItem<Row = any> = Row;
+export type DataGridData<Row> = DataGridItem<Row>[];

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

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export type DataGridColumnFooterRender = () => ReactNode;
+export type DataGridColumnFooterNode = ReactNode;
+export type DataGridColumnFooter = DataGridColumnFooterNode | DataGridColumnFooterRender;

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

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export type DataGridColumnHeaderRender = () => ReactNode;
+export type DataGridColumnHeaderNode = ReactNode;
+export type DataGridColumnHeader = DataGridColumnHeaderNode | DataGridColumnHeaderRender;

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

@@ -0,0 +1,5 @@
+export * from './accessor';
+export * from './cell';
+export * from './data';
+export * from './footer';
+export * from './header';

package/__inner__/types/core/filter/entities/date-type.d.ts

@@ -0,0 +1,2 @@
+export declare const dataGridFilterDateType: readonly ["single", "range"];
+export type DataGridFilterDateType = (typeof dataGridFilterDateType)[number];

package/__inner__/types/core/filter/entities/group.d.ts

@@ -0,0 +1,2 @@
+export declare const dataGridFilterGroup: readonly ["main", "sub-main", "additional"];
+export type DataGridFilterGroup = (typeof dataGridFilterGroup)[number];

package/__inner__/types/core/filter/entities/index.d.ts

@@ -0,0 +1,7 @@
+export * from './date-type';
+export * from './group';
+export * from './info';
+export * from './input-validate';
+export * from './logic';
+export * from './option';
+export * from './select-type';

package/__inner__/types/core/filter/entities/info.d.ts

@@ -0,0 +1,4 @@
+import type { DataGridFilterLogic } from './logic';
+export type DataGridFilterInfo = {
+    logic: DataGridFilterLogic;
+};

package/__inner__/types/core/filter/entities/input-validate.d.ts

@@ -0,0 +1,4 @@
+import type { DataGridItem } from '../../entities';
+import type { DataGridStore } from '../../store';
+import type { DataGridStoreFilterValueType } from '../store/base';
+export type DataGridInputValidate<Item extends DataGridItem, Value> = (value: Value, type: DataGridStoreFilterValueType, context: DataGridStore<Item>) => boolean;

package/__inner__/types/core/filter/entities/logic.d.ts

@@ -0,0 +1,2 @@
+export declare const dataGridFilterLogic: readonly ["immediate", "confirmable"];
+export type DataGridFilterLogic = (typeof dataGridFilterLogic)[number];

package/__inner__/types/core/filter/entities/option.d.ts

@@ -0,0 +1,4 @@
+export type DataGridFilterOption = {
+    value: string | number;
+    label: string;
+};

package/__inner__/types/core/filter/entities/select-type.d.ts

@@ -0,0 +1,2 @@
+export declare const dataGridFilterSelectType: readonly ["single", "multiple"];
+export type DataGridFilterSelectType = (typeof dataGridFilterSelectType)[number];

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

@@ -0,0 +1,4 @@
+export * from './useDataGridFilter';
+export * from './useDataGridFilterEvents';
+export * from './useDataGridFilters';
+export * from './useDataGridFiltersEvents';