@ozen-ui/data-grid 0.73.0

package/__inner__/types/core/filter/table/inputs/string/DataGridStringTableFilter.d.ts

@@ -0,0 +1,5 @@
+import type { DataGridItem } from '../../../../entities';
+import { DataGridInputTableFilter } from '../base';
+import type { DataGridStringTableFilterRender, DataGridStringTableFilterValue } from './types';
+export declare class DataGridStringTableFilter<Item extends DataGridItem> extends DataGridInputTableFilter<Item, DataGridStringTableFilterValue, DataGridStringTableFilterRender<Item>> {
+}

package/__inner__/types/core/filter/table/inputs/string/index.d.ts

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

package/__inner__/types/core/filter/table/inputs/string/types.d.ts

@@ -0,0 +1,7 @@
+import type { DataGridItem } from '../../../../entities';
+import type { DataGridStoreStringFilter } from '../../../store';
+import type { DataGridTableFilterRender } from '../../base';
+import type { DataGridInputTableFilterParams } from '../base';
+export type DataGridStringTableFilterRender<Item extends DataGridItem> = DataGridTableFilterRender<Item, DataGridStoreStringFilter<Item>>;
+export type DataGridStringTableFilterValue = string;
+export type DataGridStringTableFilterParams<Item extends DataGridItem> = DataGridInputTableFilterParams<Item, DataGridStringTableFilterValue, DataGridStringTableFilterRender<Item>>;

package/__inner__/types/core/filter/table/select/DataGridSelectTableFilter.d.ts

@@ -0,0 +1,9 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import { DataGridTableFilter } from '../base';
+import type { DataGridSelectTableFilterParams, DataGridSelectTableFilterRender } from './types';
+export declare class DataGridSelectTableFilter<Item extends DataGridItem, Option extends DataGridFilterOption> extends DataGridTableFilter<Item, DataGridSelectTableFilterRender<Item, Option>> {
+    options: Option[];
+    type: DataGridFilterSelectType;
+    constructor({ options, type, ...other }: DataGridSelectTableFilterParams<Item, Option>);
+}

package/__inner__/types/core/filter/table/select/index.d.ts

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

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

@@ -0,0 +1,9 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridStoreSelectFilter } from '../../store';
+import type { DataGridTableFilterParams, DataGridTableFilterRender } from '../base';
+export type DataGridSelectTableFilterRender<Item extends DataGridItem, Option extends DataGridFilterOption = DataGridFilterOption> = DataGridTableFilterRender<Item, DataGridStoreSelectFilter<Item, Option>>;
+export type DataGridSelectTableFilterParams<Item extends DataGridItem, Option extends DataGridFilterOption> = DataGridTableFilterParams<Item, DataGridSelectTableFilterRender<Item, Option>> & {
+    options?: Option[];
+    type?: DataGridFilterSelectType;
+};

package/__inner__/types/core/filter/types/DataGridStoreFilterExtractEvents.d.ts

@@ -0,0 +1,2 @@
+import type { DataGridStoreFilter } from '../store';
+export type DataGridStoreFilterExtractEvents<Filter extends DataGridStoreFilter<any, any>> = Filter extends DataGridStoreFilter<any, any, infer Events> ? Events : never;

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

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

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

@@ -0,0 +1,11 @@
+export * from './column';
+export * from './columns-group';
+export * from './entities';
+export * from './filter';
+export * from './modals';
+export * from './pagination';
+export * from './row';
+export * from './selection';
+export * from './store';
+export * from './sub-row';
+export * from './table';

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

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

package/__inner__/types/core/modals/entities/name.d.ts

@@ -0,0 +1,2 @@
+export declare const dataGridStoreModalName: readonly ["columns-settings", "filters"];
+export type DataGridStoreModalName = (typeof dataGridStoreModalName)[number];

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

@@ -0,0 +1,2 @@
+export * from './entities';
+export * from './store';

package/__inner__/types/core/modals/store/DataGridStoreModals.d.ts

@@ -0,0 +1,15 @@
+import type { DataGridItem } from '../../entities';
+import type { DataGridStore } from '../../store';
+import type { DataGridStoreModalName } from '../entities';
+export declare class DataGridStoreModals<Item extends DataGridItem> {
+    openByName: Partial<Record<DataGridStoreModalName, boolean>>;
+    context: DataGridStore<Item>;
+    constructor(context: DataGridStore<Item>);
+    isOpen(name: DataGridStoreModalName): boolean;
+    open(name: DataGridStoreModalName): void;
+    close(name: DataGridStoreModalName): void;
+    openColumnsSettings(): void;
+    closeColumnsSettings(): void;
+    openFilters(): void;
+    closeFilters(): void;
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './info';
+export * from './params';

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

@@ -0,0 +1,5 @@
+import type { WithRequired } from "@ozen-ui/kit/types";
+import type { DataGridPaginationParams } from './params';
+export type DataGridPaginationInfo = {
+    isEnabled: boolean;
+} & WithRequired<DataGridPaginationParams, 'availableSizes'>;

package/__inner__/types/core/pagination/entities/params.d.ts

@@ -0,0 +1,5 @@
+export type DataGridPaginationParams = {
+    pageSize: number;
+    total: number;
+    availableSizes?: number[];
+};

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

@@ -0,0 +1,2 @@
+export * from './useDataGridPagination';
+export * from './useDataGridPaginationEvents';

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

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

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

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

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

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

package/__inner__/types/core/pagination/store/DataGridStorePagination.d.ts

@@ -0,0 +1,23 @@
+import { EventBus } from '../../../shared';
+import type { DataGridItem } from '../../entities';
+import type { DataGridStore } from '../../store';
+import type { DataGridPaginationInfo } from '../entities';
+import type { DataGridStorePaginationEvents } from './types';
+export declare class DataGridStorePagination<Item extends DataGridItem> {
+    index: number;
+    total: number;
+    pageSize: number;
+    isEnabled: boolean;
+    availableSizes: number[];
+    context: DataGridStore<Item>;
+    eventBus: EventBus<DataGridStorePaginationEvents>;
+    constructor({ total, isEnabled, pageSize, availableSizes }: DataGridPaginationInfo, context: DataGridStore<Item>);
+    setAvailableSizes(sizes: number[]): void;
+    setPageSize(size: number): void;
+    setIndex(index: number): void;
+    setTotal(total: number): void;
+    setIsEnabled(isEnabled: boolean): void;
+    enable(): void;
+    disable(): void;
+    get isAvailableSizeEnabled(): boolean;
+}

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

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

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

@@ -0,0 +1,15 @@
+export declare const dataGridStorePaginationEvent: {
+    readonly CHANGE_AVAILABLE_SIZES: "changeAvailableSizes";
+    readonly CHANGE_PAGE_SIZE: "changePageSize";
+    readonly CHANGE_INDEX: "changeIndex";
+    readonly CHANGE_TOTAL: "changeTotal";
+    readonly CHANGE_IS_ENABLED: "changeIsEnabled";
+};
+export type DataGridStorePaginationEvent = (typeof dataGridStorePaginationEvent)[keyof typeof dataGridStorePaginationEvent];
+export type DataGridStorePaginationEvents = {
+    [dataGridStorePaginationEvent.CHANGE_AVAILABLE_SIZES]: number[];
+    [dataGridStorePaginationEvent.CHANGE_PAGE_SIZE]: number;
+    [dataGridStorePaginationEvent.CHANGE_INDEX]: number;
+    [dataGridStorePaginationEvent.CHANGE_TOTAL]: number;
+    [dataGridStorePaginationEvent.CHANGE_IS_ENABLED]: boolean;
+};

package/__inner__/types/core/row/entities/id.d.ts

@@ -0,0 +1,2 @@
+import type { DataGridItem } from '../../entities';
+export type DataGridGenerateRowId<Item extends DataGridItem> = (item: Item) => string;

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './info';
+export * from './type';

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

@@ -0,0 +1,5 @@
+import type { DataGridSelectionType } from './type';
+export type DataGridSelectionInfo = {
+    isEnabled: boolean;
+    type: DataGridSelectionType;
+};

package/__inner__/types/core/selection/entities/type.d.ts

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

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

@@ -0,0 +1,2 @@
+export * from './useDataGridSelection';
+export * from './useDataGridSelectionEvents';

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

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

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

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

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

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

package/__inner__/types/core/selection/store/DataGridStoreSelection.d.ts

@@ -0,0 +1,29 @@
+import { EventBus } from '../../../shared';
+import type { DataGridItem } from '../../entities';
+import type { DataGridStore } from '../../store';
+import type { DataGridSelectionInfo, DataGridSelectionType } from '../entities';
+import type { DataGridStoreSelectionEvents } from './types';
+export declare class DataGridStoreSelection<Item extends DataGridItem> {
+    isEnabled: boolean;
+    protected rawSelectedRows: Record<string, boolean>;
+    type: DataGridSelectionType;
+    context: DataGridStore<Item>;
+    eventBus: EventBus<DataGridStoreSelectionEvents>;
+    constructor({ isEnabled, type }: DataGridSelectionInfo, context: DataGridStore<Item>);
+    get selectedRows(): string[];
+    get isSingle(): boolean;
+    get isMultiple(): boolean;
+    setType(type: DataGridSelectionType): void;
+    get selectedCount(): number;
+    get isAllSelected(): boolean;
+    get isSomeSelected(): boolean;
+    selectAll(): void;
+    unselectAll(): void;
+    getIsSelectedRow(id: string): boolean;
+    setRowSelected(id: string, isSelected: boolean): void;
+    selectRow(id: string): void;
+    unselectRow(id: string): void;
+    setIsEnabled(isEnabled: boolean): void;
+    enable(): void;
+    disable(): void;
+}

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

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

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

@@ -0,0 +1,15 @@
+import type { DataGridSelectionType } from '../entities';
+export declare const dataGridStoreSelectionEvent: {
+    readonly CHANGE: "change";
+    readonly CHANGE_IS_ENABLED: "changeIsEnabled";
+    readonly CHANGE_TYPE: "changeType";
+};
+export type DataGridStoreSelectionEvent = (typeof dataGridStoreSelectionEvent)[keyof typeof dataGridStoreSelectionEvent];
+export type DataGridStoreSelectionEvents = {
+    [dataGridStoreSelectionEvent.CHANGE]: {
+        rowId: string;
+        isSelected: boolean;
+    };
+    [dataGridStoreSelectionEvent.CHANGE_IS_ENABLED]: boolean;
+    [dataGridStoreSelectionEvent.CHANGE_TYPE]: DataGridSelectionType;
+};

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

@@ -0,0 +1,53 @@
+import { EventBus } from '../../shared';
+import type { DataGridColumnsInfo, DataGridColumnVerticalAlign } from '../column';
+import { DataGridColumn, DataGridStoreColumn } from '../column';
+import { DataGridColumnsGroup, DataGridStoreColumnsGroup } from '../columns-group';
+import type { DataGridData, DataGridItem } from '../entities';
+import { DataGridStoreFilters } from '../filter';
+import { DataGridStoreModals } from '../modals';
+import { DataGridStorePagination } from '../pagination';
+import type { DataGridGenerateRowId } from '../row';
+import { DataGridStoreSelection } from '../selection';
+import { DataGridStoreSubRows } from '../sub-row';
+import type { DataGridTable } from '../table';
+import type { DataGridStoreEvents, DataGridStoreStatus, DataGridStoreWithEmptyStatus } from './entities';
+export declare class DataGridStore<Item extends DataGridItem> {
+    nodes: (DataGridStoreColumn<Item> | DataGridStoreColumnsGroup<Item>)[];
+    data: DataGridData<Item>;
+    subRows: DataGridStoreSubRows<Item>;
+    generateRowId: DataGridGenerateRowId<Item>;
+    pagination: DataGridStorePagination<Item>;
+    protected rawStatus: DataGridStoreStatus;
+    modals: DataGridStoreModals<Item>;
+    selection: DataGridStoreSelection<Item>;
+    filters: DataGridStoreFilters<Item>;
+    columnsInfo: DataGridColumnsInfo<Item, unknown>;
+    eventBus: EventBus<DataGridStoreEvents<Item>>;
+    constructor(table: DataGridTable<Item>, data: DataGridData<Item>);
+    findColumn<AccessorReturn>(tableColumn: DataGridColumn<Item, AccessorReturn>): DataGridStoreColumn<Item, AccessorReturn>;
+    findGroup(tableGroup: DataGridColumnsGroup<Item>): DataGridStoreColumnsGroup<Item>;
+    setVerticalAlign(align: DataGridColumnVerticalAlign): void;
+    get groupById(): Record<string, DataGridStoreColumnsGroup<Item>>;
+    get columnById(): Record<string, DataGridStoreColumn<Item, unknown>>;
+    recalculate(): void;
+    get status(): DataGridStoreWithEmptyStatus;
+    setStatus(status: DataGridStoreStatus): void;
+    get colSpan(): number;
+    get isLoading(): boolean;
+    get isPlaceholder(): boolean;
+    get isDefault(): boolean;
+    get isEmpty(): boolean;
+    setLoading(): void;
+    setDefault(): void;
+    get columnsCount(): number;
+    get allColumns(): DataGridStoreColumn<Item, unknown>[];
+    get columns(): DataGridStoreColumn<Item, unknown>[];
+    get visibleNodes(): (DataGridStoreColumn<Item, unknown> | DataGridStoreColumnsGroup<Item>)[];
+    get footerNodes(): (DataGridStoreColumn<Item, unknown>[] | DataGridStoreColumnsGroup<Item>[])[];
+    get headerNodes(): (DataGridStoreColumn<Item, unknown>[] | DataGridStoreColumnsGroup<Item>[])[];
+    addColumn<AccessorReturn>(column: DataGridStoreColumn<Item, AccessorReturn>): DataGridStoreColumn<Item, AccessorReturn>;
+    addGroup(group: DataGridStoreColumnsGroup<Item>): DataGridStoreColumnsGroup<Item>;
+    setData(data: DataGridData<Item>): void;
+    get dataById(): Record<string, Item>;
+    getNodesByDepth(isVisibleOnly: boolean): (DataGridStoreColumn<Item, unknown>[] | DataGridStoreColumnsGroup<Item>[])[];
+}

package/__inner__/types/core/store/entities/events.d.ts

@@ -0,0 +1,21 @@
+import type { DataGridStoreColumn } from '../../column';
+import type { DataGridStoreColumnsGroup } from '../../columns-group';
+import type { DataGridData, DataGridItem } from '../../entities';
+import type { DataGridStoreWithEmptyStatus } from './status';
+export declare const dataGridStoreEvent: {
+    readonly RECALCULATE: "recalculate";
+    readonly CHANGE_STATUS: "changeStatus";
+    readonly ADD_COLUMN: "addColumn";
+    readonly ADD_GROUP: "addGroup";
+    readonly CHANGE_DATA: "changeData";
+    readonly CHANGE_SORTING: "changeSorting";
+};
+export type DataGridStoreEvent = (typeof dataGridStoreEvent)[keyof typeof dataGridStoreEvent];
+export type DataGridStoreEvents<Item extends DataGridItem> = {
+    [dataGridStoreEvent.RECALCULATE]: null;
+    [dataGridStoreEvent.CHANGE_STATUS]: DataGridStoreWithEmptyStatus;
+    [dataGridStoreEvent.ADD_COLUMN]: DataGridStoreColumn<Item>;
+    [dataGridStoreEvent.ADD_GROUP]: DataGridStoreColumnsGroup<Item>;
+    [dataGridStoreEvent.CHANGE_DATA]: DataGridData<Item>;
+    [dataGridStoreEvent.CHANGE_SORTING]: DataGridStoreColumn<Item>;
+};

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

@@ -0,0 +1,2 @@
+export * from './events';
+export * from './status';

package/__inner__/types/core/store/entities/status.d.ts

@@ -0,0 +1,4 @@
+export declare const dataGridStoreStatus: readonly ["default", "loading"];
+export type DataGridStoreStatus = (typeof dataGridStoreStatus)[number];
+export declare const dataGridStoreWithEmptyStatus: readonly ["default", "loading", "empty"];
+export type DataGridStoreWithEmptyStatus = (typeof dataGridStoreWithEmptyStatus)[number];

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

@@ -0,0 +1,3 @@
+export * from './useDataGridCreateStore';
+export * from './useDataGridStore';
+export * from './useDataGridStoreEvents';

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

@@ -0,0 +1,4 @@
+import type { DataGridData } 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>;

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

@@ -0,0 +1 @@
+export declare const useDataGridStore: <Item extends unknown>() => import("..").DataGridStore<Item>;

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

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

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

@@ -0,0 +1,5 @@
+export * from './entities';
+export * from './hooks';
+export * from './utils';
+export * from './DataGridStore';
+export * from './types';

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

@@ -0,0 +1,3 @@
+import type { DataGridItem } from '../entities';
+import type { DataGridStoreAutocompleteFilter, DataGridStoreAutocompleteListCardFilter, DataGridStoreDateFilter, DataGridStoreNumberFilter, DataGridStoreSelectFilter, DataGridStoreStringFilter, DataGridAutocompleteTableFilter, DataGridAutocompleteListCardTableFilter, DataGridTableFilter, DataGridDateTableFilter, DataGridNumberTableFilter, DataGridStringTableFilter, DataGridSelectTableFilter } from '../filter';
+export type DataGridTableFilterToStore<Item extends DataGridItem, Filter extends DataGridTableFilter<Item>> = Filter extends DataGridSelectTableFilter<Item, infer Option> ? DataGridStoreSelectFilter<Item, Option> : Filter extends DataGridAutocompleteTableFilter<Item, infer Option> ? DataGridStoreAutocompleteFilter<Item, Option> : Filter extends DataGridAutocompleteListCardTableFilter<Item, infer Option> ? DataGridStoreAutocompleteListCardFilter<Item, Option> : Filter extends DataGridDateTableFilter<Item> ? DataGridStoreDateFilter<Item> : Filter extends DataGridNumberTableFilter<Item> ? DataGridStoreNumberFilter<Item> : Filter extends DataGridStringTableFilter<Item> ? DataGridStoreStringFilter<Item> : never;

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

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

package/__inner__/types/core/store/utils/observer/index.d.ts

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

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

@@ -0,0 +1,2 @@
+import { observer } from 'mobx-react-lite';
+export { observer as dataGridObserver };

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

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

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

@@ -0,0 +1,2 @@
+export declare const dataGridSubRowPosition: readonly ["left", "right"];
+export type DataGridSubRowPosition = (typeof dataGridSubRowPosition)[number];

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

@@ -0,0 +1,5 @@
+import type { DataGridSubRowPosition } from './position';
+export type DataGridSubRowSettings = {
+    position: DataGridSubRowPosition;
+    isWithMargin: boolean;
+};

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

@@ -0,0 +1,4 @@
+export * from './useDataGridSubRow';
+export * from './useDataGridSubRowEvents';
+export * from './useDataGridSubRows';
+export * from './useDataGridSubRowsEvents';

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './sub-row';
+export * from './sub-rows';

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

@@ -0,0 +1,28 @@
+import type { ReactNode } from 'react';
+import { EventBus } from '../../../../shared';
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridSubRow } from '../../table';
+import type { DataGridStoreSubRowEvents } from './types';
+export declare class DataGridStoreSubRow<Item extends DataGridItem> {
+    id: string;
+    root: DataGridStoreSubRow<Item> | null;
+    rows: DataGridStoreSubRow<Item>[];
+    expandedByRowId: Record<string, boolean>;
+    render: (item: Item, index: number) => ReactNode;
+    context: DataGridStore<Item>;
+    eventBus: EventBus<DataGridStoreSubRowEvents<Item>>;
+    private readonly getIsVisible;
+    constructor(subRow: DataGridSubRow<Item>, context: DataGridStore<Item>, root?: DataGridStoreSubRow<Item>);
+    get isRoot(): boolean;
+    generateId(index: number): string;
+    getIsExpanded(id: string): boolean;
+    expand(id: string): void;
+    collapse(id: string): void;
+    toggle(id: string): void;
+    isVisible(item: Item, index: number): boolean;
+    isSomeRowsVisible(item: Item, index: number): boolean;
+    get canExpand(): boolean;
+    get depth(): number;
+    addSubRow(subRow: DataGridStoreSubRow<Item>): DataGridStoreSubRow<Item>;
+}

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

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

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

@@ -0,0 +1,14 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStoreSubRow } from './DataGridStoreSubRow';
+export declare const dataGridStoreSubRowEvent: {
+    readonly CHANGE_EXPANDED: "changeExpanded";
+    readonly ADD_SUB_ROW: "addSubRow";
+};
+export type DataGridStoreSubRowEvent = (typeof dataGridStoreSubRowEvent)[keyof typeof dataGridStoreSubRowEvent];
+export type DataGridStoreSubRowEvents<Item extends DataGridItem> = {
+    [dataGridStoreSubRowEvent.CHANGE_EXPANDED]: {
+        rowId: string;
+        isExpanded: boolean;
+    };
+    [dataGridStoreSubRowEvent.ADD_SUB_ROW]: DataGridStoreSubRow<Item>;
+};

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

@@ -0,0 +1,34 @@
+import { EventBus } from '../../../../shared';
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridSubRowPosition, DataGridSubRowSettings } from '../../entities';
+import type { DataGridSubRow } from '../../table';
+import { DataGridStoreSubRow } from '../sub-row';
+import type { DataGridStoreSubRowsEvents } from './types';
+export declare class DataGridStoreSubRows<Item extends DataGridItem> {
+    rows: DataGridStoreSubRow<Item>[];
+    context: DataGridStore<Item>;
+    position: DataGridSubRowPosition;
+    expandedRootsByRowId: Record<string, boolean>;
+    isWithMargin: boolean;
+    eventBus: EventBus<DataGridStoreSubRowsEvents<Item>>;
+    constructor(settings: DataGridSubRowSettings, subRows: DataGridSubRow<Item>[], context: DataGridStore<Item>);
+    collapseNotExistRows(): void;
+    findRow(tableSubRow: DataGridSubRow<Item>): DataGridStoreSubRow<Item>;
+    get rowById(): Record<string, DataGridStoreSubRow<Item>>;
+    get isEnabled(): boolean;
+    get isLeft(): boolean;
+    get isRight(): boolean;
+    setPosition(position: DataGridSubRowPosition): void;
+    setIsWithMargin(isWithMargin: boolean): void;
+    enableMargin(): void;
+    disableMargin(): void;
+    get canExpandRoot(): boolean;
+    isSomeRowsVisible(id: string, index: number): boolean;
+    expandRoot(rowId: string): void;
+    collapseAll(): void;
+    collapseRoot(rowId: string): void;
+    toggleRoot(id: string): void;
+    getIsExpandedRoot(rowId: string): boolean;
+    addSubRow(subRow: DataGridStoreSubRow<Item>): DataGridStoreSubRow<Item>;
+}

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

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

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

@@ -0,0 +1,20 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStoreSubRow } from '../sub-row';
+export declare const dataGridStoreSubRowsEvent: {
+    readonly CHANGE_EXPANDED_ROOT: "changeExpandedRoot";
+    readonly CHANGE_EXPANDED: "changeExpanded";
+    readonly ADD_SUB_ROW: "addSubRow";
+};
+export type DataGridStoreSubRowsEvent = (typeof dataGridStoreSubRowsEvent)[keyof typeof dataGridStoreSubRowsEvent];
+export type DataGridStoreSubRowsEvents<Item extends DataGridItem> = {
+    [dataGridStoreSubRowsEvent.CHANGE_EXPANDED_ROOT]: {
+        rowId: string;
+        isExpanded: boolean;
+    };
+    [dataGridStoreSubRowsEvent.CHANGE_EXPANDED]: {
+        id: 'root' | string;
+        rowId: string;
+        isExpanded: boolean;
+    };
+    [dataGridStoreSubRowsEvent.ADD_SUB_ROW]: DataGridStoreSubRow<Item>;
+};

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

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { DataGridItem } 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;
+    isVisible: (item: Item, index: number) => boolean;
+    constructor({ id, render, isVisible }: DataGridSubRowParams<Item>);
+    get id(): string;
+    setRoot(root: DataGridSubRow<Item>): void;
+    get depth(): number;
+    createSubRow(params: DataGridSubRowParams<Item>): DataGridSubRow<Item>;
+    addSubRow(subRow: DataGridSubRow<Item>): DataGridSubRow<Item>;
+}

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

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

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

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