@ozen-ui/data-grid 0.73.0

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+import { EventBus } from '../../../shared';
+import type { DataGridItem } from '../../entities';
+import type { DataGridStore, DataGridTableFilterToStore } from '../../store';
+import type { DataGridFilterInfo, DataGridFilterLogic } from '../entities';
+import type { DataGridTableFilter } from '../table';
+import type { DataGridStoreFiltersEvents, DataGridStoreFilterType } from './types';
+export declare class DataGridStoreFilters<Item extends DataGridItem> {
+    filters: DataGridStoreFilterType<Item>[];
+    logic: DataGridFilterLogic;
+    context: DataGridStore<Item>;
+    eventBus: EventBus<DataGridStoreFiltersEvents<Item>>;
+    constructor(filterInfo: DataGridFilterInfo, context: DataGridStore<Item>);
+    register(): void;
+    addFilter<Filter extends DataGridStoreFilterType<Item>>(filter: Filter): void;
+    findFilter<Filter extends DataGridTableFilter<Item>>(tableFilter: Filter): DataGridTableFilterToStore<Item, Filter>;
+    get filterById(): Record<string, DataGridStoreFilterType<Item>>;
+    setLogic(logic: DataGridFilterLogic): void;
+    get isImmediate(): boolean;
+    get isConfirmable(): boolean;
+    get isSomeMainEdited(): boolean;
+    get isSomeAdditionalEdited(): boolean;
+    get isSomeEdited(): boolean;
+    get isSomeAllFiltersEdited(): boolean;
+    get isSomeMainActive(): boolean;
+    get isSomeAdditionalActive(): boolean;
+    get isSomeActive(): boolean;
+    get mainFilters(): DataGridStoreFilterType<Item>[];
+    get subMainFilters(): DataGridStoreFilterType<Item>[];
+    get additionalFilters(): DataGridStoreFilterType<Item>[];
+    applyAdditionalLocals(): void;
+    applyMainLocals(): void;
+    applyAllFilters(): void;
+    applyLocals(): void;
+    resetAll(): void;
+    resetMainLocals(): void;
+    resetAdditionalLocals(): void;
+    resetAllLocals(): void;
+    resetAllFilters(): void;
+}

package/__inner__/types/core/filter/store/autocomplete/DataGridStoreAutocompleteFilter.d.ts

@@ -0,0 +1,13 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridAutocompleteTableFilter } from '../../table';
+import type { DataGridStoreFilterRender } from '../base';
+import { DataGridStoreBaseSelectFilter } from '../select';
+import type { DataGridStoreAutocompleteFilterEvents } from './types';
+export declare class DataGridStoreAutocompleteFilter<Item extends DataGridItem, Option extends DataGridFilterOption> extends DataGridStoreBaseSelectFilter<Item, Option, DataGridStoreAutocompleteFilterEvents<Option>, DataGridAutocompleteTableFilter<Item, Option>> {
+    options: Option[];
+    type: DataGridFilterSelectType;
+    render: DataGridStoreFilterRender | null;
+    constructor(filter: DataGridAutocompleteTableFilter<Item, Option>, context: DataGridStore<Item>);
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { DataGridFilterOption } from '../../entities';
+import type { DataGridStoreSelectFilterEvents } from '../select';
+export declare const dataGridStoreAutocompleteFilterEvent: {
+    readonly CHANGE_TYPE: "changeType";
+    readonly CHANGE_OPTIONS: "changeOptions";
+    readonly CHANGE_VALUE: "changeValue";
+    readonly CHANGE_LOCAL_VALUE: "changeLocalValue";
+    readonly CHANGE_ALL_FILTER_VALUE: "changeAllFilterValue";
+};
+export type DataGridStoreAutocompleteFilterEvent = (typeof dataGridStoreAutocompleteFilterEvent)[keyof typeof dataGridStoreAutocompleteFilterEvent];
+export type DataGridStoreAutocompleteFilterEvents<Option extends DataGridFilterOption> = DataGridStoreSelectFilterEvents<Option>;

package/__inner__/types/core/filter/store/autocompleteListCard/DataGridStoreAutocompleteListCardFilter.d.ts

@@ -0,0 +1,13 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridAutocompleteListCardTableFilter } from '../../table';
+import type { DataGridStoreFilterRender } from '../base';
+import { DataGridStoreBaseSelectFilter } from '../select';
+import type { DataGridStoreAutocompleteListCardFilterEvents } from './types';
+export declare class DataGridStoreAutocompleteListCardFilter<Item extends DataGridItem, Option extends DataGridFilterOption> extends DataGridStoreBaseSelectFilter<Item, Option, DataGridStoreAutocompleteListCardFilterEvents<Option>, DataGridAutocompleteListCardTableFilter<Item, Option>> {
+    options: Option[];
+    type: DataGridFilterSelectType;
+    render: DataGridStoreFilterRender;
+    constructor(filter: DataGridAutocompleteListCardTableFilter<Item, Option>, context: DataGridStore<Item>);
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { DataGridFilterOption } from '../../entities';
+import type { DataGridStoreSelectFilterEvents } from '../select';
+export declare const dataGridStoreAutocompleteListCardFilterEvent: {
+    readonly CHANGE_TYPE: "changeType";
+    readonly CHANGE_OPTIONS: "changeOptions";
+    readonly CHANGE_VALUE: "changeValue";
+    readonly CHANGE_LOCAL_VALUE: "changeLocalValue";
+    readonly CHANGE_ALL_FILTER_VALUE: "changeAllFilterValue";
+};
+export type DataGridStoreAutocompleteListCardFilterEvent = (typeof dataGridStoreAutocompleteListCardFilterEvent)[keyof typeof dataGridStoreAutocompleteListCardFilterEvent];
+export type DataGridStoreAutocompleteListCardFilterEvents<Option extends DataGridFilterOption> = DataGridStoreSelectFilterEvents<Option>;

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

@@ -0,0 +1,42 @@
+import { EventBus } from '../../../../shared';
+import type { DataGridStoreColumn } from '../../../column';
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridFilterGroup } from '../../entities';
+import type { DataGridTableFilter } from '../../table';
+import type { DataGridStoreFilterEvents, DataGridStoreFilterRender, DataGridStoreFilterValueType } from './types';
+export declare abstract class DataGridStoreFilter<Item extends DataGridItem, Value = unknown, Events extends DataGridStoreFilterEvents<Value> = DataGridStoreFilterEvents<Value>> {
+    id: string;
+    protected rawName: string | null;
+    protected context: DataGridStore<Item>;
+    column: DataGridStoreColumn<Item> | null;
+    group: DataGridFilterGroup;
+    abstract value: Value;
+    abstract localValue: Value;
+    abstract allFilterValue: Value;
+    abstract render: DataGridStoreFilterRender | null;
+    eventBus: EventBus<Events>;
+    constructor(filter: DataGridTableFilter<Item>, context: DataGridStore<Item>);
+    abstract get isActive(): boolean;
+    abstract reset(): void;
+    register(): void;
+    get isCustomRender(): boolean;
+    setValue(value: Value): void;
+    setLocalValue(value: Value): void;
+    setAllFilterValue(value: Value): void;
+    resetLocal(): void;
+    resetAllFilter(): void;
+    applyLocal(): void;
+    applyAllFilter(): void;
+    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;
+    get isMain(): boolean;
+    get isSubMain(): boolean;
+    get isAdditional(): boolean;
+    get name(): string;
+}

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

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

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

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+export declare const dataGridStoreFilterValueType: readonly ["default", "local", "allFilter"];
+export type DataGridStoreFilterValueType = (typeof dataGridStoreFilterValueType)[number];
+export type DataGridStoreFilterRender = (params: {
+    type: DataGridStoreFilterValueType;
+}) => ReactNode;
+export declare const dataGridStoreFilterEvent: {
+    readonly CHANGE_VALUE: "changeValue";
+    readonly CHANGE_LOCAL_VALUE: "changeLocalValue";
+    readonly CHANGE_ALL_FILTER_VALUE: "changeAllFilterValue";
+};
+export type DataGridStoreFilterEvent = (typeof dataGridStoreFilterEvent)[keyof typeof dataGridStoreFilterEvent];
+export type DataGridStoreFilterEvents<Value> = {
+    [dataGridStoreFilterEvent.CHANGE_VALUE]: Value;
+    [dataGridStoreFilterEvent.CHANGE_LOCAL_VALUE]: Value;
+    [dataGridStoreFilterEvent.CHANGE_ALL_FILTER_VALUE]: Value;
+};

package/__inner__/types/core/filter/store/date/DataGridStoreDateFilter.d.ts

@@ -0,0 +1,27 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridFilterDateType } from '../../entities';
+import type { DataGridDateTableFilter } from '../../table';
+import type { DataGridStoreFilterRender } from '../base';
+import { DataGridStoreFilter } from '../base';
+import type { DataGridStoreDateFilterEvents, DataGridStoreDateFilterValue } from './types';
+export declare class DataGridStoreDateFilter<Item extends DataGridItem> extends DataGridStoreFilter<Item, DataGridStoreDateFilterValue, DataGridStoreDateFilterEvents> {
+    min: Date | null;
+    max: Date | null;
+    type: DataGridFilterDateType;
+    value: DataGridStoreDateFilterValue;
+    localValue: DataGridStoreDateFilterValue;
+    allFilterValue: DataGridStoreDateFilterValue;
+    render: DataGridStoreFilterRender | null;
+    constructor(filter: DataGridDateTableFilter<Item>, context: DataGridStore<Item>);
+    get isActive(): boolean;
+    protected processValue(value: DataGridStoreDateFilterValue): Date | import("./types").DataGridStoreDateFilterRangeValue | null;
+    isEqualValues(value1: DataGridStoreDateFilterValue, value2: DataGridStoreDateFilterValue): boolean;
+    setValue(value: DataGridStoreDateFilterValue): void;
+    setLocalValue(value: DataGridStoreDateFilterValue): void;
+    setAllFilterValue(value: DataGridStoreDateFilterValue): void;
+    reset(): void;
+    setMin(min: Date | null): void;
+    setMax(max: Date | null): void;
+    setType(type: DataGridFilterDateType): void;
+}

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

@@ -0,0 +1,3 @@
+export * from './DataGridStoreDateFilter';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,22 @@
+import type { DataGridFilterDateType } from '../../entities';
+import type { DataGridStoreFilterEvents } from '../base';
+export type DataGridStoreDateFilterSingleValue = Date;
+export type DataGridStoreDateFilterRangeValue = {
+    from: Date | null;
+    to: Date | null;
+};
+export type DataGridStoreDateFilterValue = DataGridStoreDateFilterSingleValue | DataGridStoreDateFilterRangeValue | null;
+export declare const dataGridStoreDateFilterEvent: {
+    readonly CHANGE_TYPE: "changeType";
+    readonly CHANGE_MIN: "changeMin";
+    readonly CHANGE_MAX: "changeMax";
+    readonly CHANGE_VALUE: "changeValue";
+    readonly CHANGE_LOCAL_VALUE: "changeLocalValue";
+    readonly CHANGE_ALL_FILTER_VALUE: "changeAllFilterValue";
+};
+export type DataGridStoreDateFilterEvent = (typeof dataGridStoreDateFilterEvent)[keyof typeof dataGridStoreDateFilterEvent];
+export type DataGridStoreDateFilterEvents = DataGridStoreFilterEvents<DataGridStoreDateFilterValue> & {
+    [dataGridStoreDateFilterEvent.CHANGE_TYPE]: DataGridFilterDateType;
+    [dataGridStoreDateFilterEvent.CHANGE_MIN]: Date | null;
+    [dataGridStoreDateFilterEvent.CHANGE_MAX]: Date | null;
+};

package/__inner__/types/core/filter/store/date/utils.d.ts

@@ -0,0 +1,3 @@
+import type { DataGridStoreDateFilterRangeValue, DataGridStoreDateFilterSingleValue } from './types';
+export declare const isDateFilterRangeValue: (value: unknown) => value is DataGridStoreDateFilterRangeValue;
+export declare const isDateFilterSingleValue: (value: unknown) => value is DataGridStoreDateFilterSingleValue;

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

@@ -0,0 +1,8 @@
+export * from './autocomplete';
+export * from './autocompleteListCard';
+export * from './base';
+export * from './date';
+export * from './inputs';
+export * from './select';
+export * from './DataGridStoreFilters';
+export * from './types';

package/__inner__/types/core/filter/store/inputs/DataGridStoreNumberFilter.d.ts

@@ -0,0 +1,6 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridNumberTableFilter } from '../../table';
+import { DataGridStoreInputFilter } from './base';
+export declare class DataGridStoreNumberFilter<Item extends DataGridItem> extends DataGridStoreInputFilter<Item, number, DataGridNumberTableFilter<Item>> {
+    resetValue(): void;
+}

package/__inner__/types/core/filter/store/inputs/DataGridStoreStringFilter.d.ts

@@ -0,0 +1,6 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStringTableFilter } from '../../table';
+import { DataGridStoreInputFilter } from './base';
+export declare class DataGridStoreStringFilter<Item extends DataGridItem> extends DataGridStoreInputFilter<Item, string, DataGridStringTableFilter<Item>> {
+    resetValue(): void;
+}

package/__inner__/types/core/filter/store/inputs/base/DataGridStoreInputFilter.d.ts

@@ -0,0 +1,32 @@
+import type { DataGridItem } from '../../../../entities';
+import type { DataGridStore } from '../../../../store';
+import type { DataGridInputValidate } from '../../../entities';
+import type { DataGridInputTableFilter } from '../../../table';
+import type { DataGridStoreFilterRender, DataGridStoreFilterValueType } from '../../base';
+import { DataGridStoreFilter } from '../../base';
+import type { DataGridStoreInputFilterEvents } from './types';
+export declare abstract class DataGridStoreInputFilter<Item extends DataGridItem, Value extends string | number, Filter extends DataGridInputTableFilter<Item, Value>> extends DataGridStoreFilter<Item, Value | null, DataGridStoreInputFilterEvents<Value>> {
+    value: Value | null;
+    localValue: Value | null;
+    allFilterValue: Value | null;
+    protected rawValidate: DataGridInputValidate<Item, Value | null> | null;
+    render: DataGridStoreFilterRender | null;
+    isValid: boolean;
+    isValidLocal: boolean;
+    isValidAllFilter: boolean;
+    constructor(filter: Filter, context: DataGridStore<Item>);
+    register(): void;
+    protected validate(value: Value | null, type: DataGridStoreFilterValueType): void;
+    setValue(value: Value | null): void;
+    setLocalValue(value: Value | null): void;
+    setAllFilterValue(value: Value | null): void;
+    setIsValid(isValid: boolean): void;
+    setIsValidLocal(isValid: boolean): void;
+    setIsValidAllFilter(isValid: boolean): void;
+    setIsValidByType(isValid: boolean, type: DataGridStoreFilterValueType): void;
+    isValidByType(type: DataGridStoreFilterValueType): boolean;
+    get isActive(): boolean;
+    isEqualValues(value1: Value | null, value2: Value | null): boolean;
+    abstract resetValue(): void;
+    reset(): void;
+}

package/__inner__/types/core/filter/store/inputs/base/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import type { DataGridStoreFilterEvents, DataGridStoreFilterValueType } from '../../base';
+export declare const dataGridStoreInputFilterEvent: {
+    readonly CHANGE_IS_VALID: "changeIsValid";
+    readonly CHANGE_VALUE: "changeValue";
+    readonly CHANGE_LOCAL_VALUE: "changeLocalValue";
+    readonly CHANGE_ALL_FILTER_VALUE: "changeAllFilterValue";
+};
+export type DataGridStoreInputFilterEvent = (typeof dataGridStoreInputFilterEvent)[keyof typeof dataGridStoreInputFilterEvent];
+export type DataGridStoreInputFilterEvents<Value extends string | number> = DataGridStoreFilterEvents<Value | null> & {
+    [dataGridStoreInputFilterEvent.CHANGE_IS_VALID]: {
+        isValid: boolean;
+        value: Value | null;
+        type: DataGridStoreFilterValueType;
+    };
+};

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

@@ -0,0 +1,3 @@
+export * from './base';
+export * from './DataGridStoreNumberFilter';
+export * from './DataGridStoreStringFilter';

package/__inner__/types/core/filter/store/select/DataGridStoreBaseSelectFilter.d.ts

@@ -0,0 +1,25 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridTableFilter } from '../../table';
+import { DataGridStoreFilter } from '../base';
+import type { DataGridStoreSelectFilterEvents, DataGridStoreSelectFilterValue } from './types';
+export declare abstract class DataGridStoreBaseSelectFilter<Item extends DataGridItem, Option extends DataGridFilterOption, Events extends DataGridStoreSelectFilterEvents<Option>, Filter extends DataGridTableFilter<Item>> extends DataGridStoreFilter<Item, DataGridStoreSelectFilterValue, Events> {
+    abstract options: Option[];
+    abstract type: DataGridFilterSelectType;
+    value: DataGridStoreSelectFilterValue;
+    localValue: DataGridStoreSelectFilterValue;
+    allFilterValue: DataGridStoreSelectFilterValue;
+    constructor(filter: Filter, context: DataGridStore<Item>);
+    get isActive(): boolean;
+    isEqualValues(value1: DataGridStoreSelectFilterValue, value2: DataGridStoreSelectFilterValue): boolean;
+    get isSingle(): boolean;
+    get isMultiple(): boolean;
+    get optionById(): Record<string, Option>;
+    reset(): void;
+    unselectOption(key: string): void;
+    selectOption(key: string): void;
+    setOptions(options: Option[]): void;
+    addOption(option: Option): void;
+    setType(type: DataGridFilterSelectType): void;
+}

package/__inner__/types/core/filter/store/select/DataGridStoreSelectFilter.d.ts

@@ -0,0 +1,13 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridStore } from '../../../store';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridSelectTableFilter } from '../../table';
+import type { DataGridStoreFilterRender } from '../base';
+import { DataGridStoreBaseSelectFilter } from './DataGridStoreBaseSelectFilter';
+import type { DataGridStoreSelectFilterEvents } from './types';
+export declare class DataGridStoreSelectFilter<Item extends DataGridItem, Option extends DataGridFilterOption> extends DataGridStoreBaseSelectFilter<Item, Option, DataGridStoreSelectFilterEvents<Option>, DataGridSelectTableFilter<Item, Option>> {
+    options: Option[];
+    type: DataGridFilterSelectType;
+    render: DataGridStoreFilterRender | null;
+    constructor(filter: DataGridSelectTableFilter<Item, Option>, context: DataGridStore<Item>);
+}

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

@@ -0,0 +1,3 @@
+export * from './DataGridStoreBaseSelectFilter';
+export * from './DataGridStoreSelectFilter';
+export * from './types';

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

@@ -0,0 +1,15 @@
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridStoreFilterEvents } from '../base';
+export type DataGridStoreSelectFilterValue = Set<string | number>;
+export declare const dataGridStoreSelectFilterEvent: {
+    readonly CHANGE_TYPE: "changeType";
+    readonly CHANGE_OPTIONS: "changeOptions";
+    readonly CHANGE_VALUE: "changeValue";
+    readonly CHANGE_LOCAL_VALUE: "changeLocalValue";
+    readonly CHANGE_ALL_FILTER_VALUE: "changeAllFilterValue";
+};
+export type DataGridStoreSelectFilterEvent = (typeof dataGridStoreSelectFilterEvent)[keyof typeof dataGridStoreSelectFilterEvent];
+export type DataGridStoreSelectFilterEvents<Option extends DataGridFilterOption> = DataGridStoreFilterEvents<DataGridStoreSelectFilterValue> & {
+    [dataGridStoreSelectFilterEvent.CHANGE_OPTIONS]: Option[];
+    [dataGridStoreSelectFilterEvent.CHANGE_TYPE]: DataGridFilterSelectType;
+};

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

@@ -0,0 +1,16 @@
+import type { DataGridItem } from '../../entities';
+import type { DataGridFilterOption } from '../entities';
+import type { DataGridStoreAutocompleteFilter } from './autocomplete';
+import type { DataGridStoreAutocompleteListCardFilter } from './autocompleteListCard';
+import type { DataGridStoreFilter } from './base';
+import type { DataGridStoreDateFilter } from './date';
+import type { DataGridStoreNumberFilter, DataGridStoreStringFilter } from './inputs';
+import type { DataGridStoreSelectFilter } from './select';
+export type DataGridStoreFilterType<Item extends DataGridItem> = DataGridStoreAutocompleteFilter<Item, DataGridFilterOption> | DataGridStoreAutocompleteListCardFilter<Item, DataGridFilterOption> | DataGridStoreDateFilter<Item> | DataGridStoreSelectFilter<Item, DataGridFilterOption> | DataGridStoreStringFilter<Item> | DataGridStoreNumberFilter<Item>;
+export declare const dataGridStoreFiltersEvent: {
+    readonly CHANGE_FILTER: "changeFilter";
+};
+export type DataGridStoreFiltersEvent = (typeof dataGridStoreFiltersEvent)[keyof typeof dataGridStoreFiltersEvent];
+export type DataGridStoreFiltersEvents<Item extends DataGridItem> = {
+    [dataGridStoreFiltersEvent.CHANGE_FILTER]: DataGridStoreFilter<Item>;
+};

package/__inner__/types/core/filter/table/autocomplete/DataGridAutocompleteTableFilter.d.ts

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

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

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

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

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

package/__inner__/types/core/filter/table/autocompleteListCard/DataGridAutocompleteListCardTableFilter.d.ts

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

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

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

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

@@ -0,0 +1,11 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridFilterOption, DataGridFilterSelectType } from '../../entities';
+import type { DataGridStoreAutocompleteListCardFilter } from '../../store';
+import type { DataGridTableFilterParams, DataGridTableFilterRender } from '../base';
+export type DataGridAutocompleteListCardTableFilterRender<Item extends DataGridItem, Option extends DataGridFilterOption = DataGridFilterOption> = DataGridTableFilterRender<Item, DataGridStoreAutocompleteListCardFilter<Item, Option>>;
+type WithRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type DataGridAutocompleteListCardTableFilterParams<Item extends DataGridItem, Option extends DataGridFilterOption> = WithRequired<DataGridTableFilterParams<Item, DataGridAutocompleteListCardTableFilterRender<Item, Option>>, 'render'> & {
+    options?: Option[];
+    type?: DataGridFilterSelectType;
+};
+export {};

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

@@ -0,0 +1,12 @@
+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>);
+}

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

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

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

@@ -0,0 +1,18 @@
+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';
+import type { DataGridStoreFilter, DataGridStoreFilterValueType } from '../../store';
+export type DataGridTableFilterRender<Item extends DataGridItem, Filter extends DataGridStoreFilter<Item, any> = DataGridStoreFilter<Item, any>> = (params: {
+    filter: Filter;
+    type: DataGridStoreFilterValueType;
+    context: DataGridStore<Item>;
+}) => ReactNode;
+export type DataGridTableFilterParams<Item extends DataGridItem, Render extends DataGridTableFilterRender<Item, any>> = {
+    id: string;
+    group?: DataGridFilterGroup;
+    name?: string;
+    column?: DataGridColumn<Item>;
+    render?: Render;
+};

package/__inner__/types/core/filter/table/date/DataGridDateTableFilter.d.ts

@@ -0,0 +1,10 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridFilterDateType } from '../../entities';
+import { DataGridTableFilter } from '../base';
+import type { DataGridDateTableFilterRender, DataGridDateTableFilterParams } from './types';
+export declare class DataGridDateTableFilter<Item extends DataGridItem> extends DataGridTableFilter<Item, DataGridDateTableFilterRender<Item>> {
+    min: Date | null;
+    max: Date | null;
+    type: DataGridFilterDateType;
+    constructor({ min, max, type, ...other }: DataGridDateTableFilterParams<Item>);
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { DataGridItem } from '../../../entities';
+import type { DataGridFilterDateType } from '../../entities';
+import type { DataGridStoreDateFilter } from '../../store';
+import type { DataGridTableFilterParams, DataGridTableFilterRender } from '../base';
+export type DataGridDateTableFilterRender<Item extends DataGridItem> = DataGridTableFilterRender<Item, DataGridStoreDateFilter<Item>>;
+export type DataGridDateTableFilterParams<Item extends DataGridItem> = DataGridTableFilterParams<Item, DataGridDateTableFilterRender<Item>> & {
+    min?: Date;
+    max?: Date;
+    type?: DataGridFilterDateType;
+    render?: DataGridDateTableFilterRender<Item>;
+};

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

@@ -0,0 +1,6 @@
+export * from './autocomplete';
+export * from './autocompleteListCard';
+export * from './base';
+export * from './date';
+export * from './inputs';
+export * from './select';

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

@@ -0,0 +1,9 @@
+import type { DataGridItem } from '../../../../entities';
+import type { DataGridInputValidate } from '../../../entities';
+import type { DataGridTableFilterRender } from '../../base';
+import { DataGridTableFilter } from '../../base';
+import type { DataGridInputTableFilterParams } from './types';
+export declare class DataGridInputTableFilter<Item extends DataGridItem, Value, Render extends DataGridTableFilterRender<Item, any> = DataGridTableFilterRender<Item, any>> extends DataGridTableFilter<Item, Render> {
+    validate: DataGridInputValidate<Item, Value | null> | null;
+    constructor({ validate, ...other }: DataGridInputTableFilterParams<Item, Value, Render>);
+}

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

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

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

@@ -0,0 +1,6 @@
+import type { DataGridItem } from '../../../../entities';
+import type { DataGridInputValidate } from '../../../entities';
+import type { DataGridTableFilterParams, DataGridTableFilterRender } from '../../base';
+export type DataGridInputTableFilterParams<Item extends DataGridItem, Value, Render extends DataGridTableFilterRender<Item, any> = DataGridTableFilterRender<Item, any>> = DataGridTableFilterParams<Item, Render> & {
+    validate?: DataGridInputValidate<Item, Value | null>;
+};

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

@@ -0,0 +1,3 @@
+export * from './base';
+export * from './number';
+export * from './string';

package/__inner__/types/core/filter/table/inputs/number/DataGridNumberTableFilter.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+import type { DataGridItem } from '../../../../entities';
+import type { DataGridStoreNumberFilter } from '../../../store';
+import type { DataGridTableFilterRender } from '../../base';
+import type { DataGridInputTableFilterParams } from '../base';
+export type DataGridNumberTableFilterRender<Item extends DataGridItem> = DataGridTableFilterRender<Item, DataGridStoreNumberFilter<Item>>;
+export type DataGridNumberTableFilterValue = number;
+export type DataGridNumberTableFilterParams<Item extends DataGridItem> = DataGridInputTableFilterParams<Item, DataGridNumberTableFilterValue, DataGridNumberTableFilterRender<Item>>;