@armtek/data 0.1.0

package/dist/dataTableStoreFactory.css

@@ -0,0 +1 @@
+._rowCell_e90xa_1{padding:5px!important}._rowCell__inner_e90xa_7{display:flex;align-items:center;min-height:48px;padding:0 8px}._rowHead_e90xa_21{padding:0!important;font-size:13px}._rowHead__inner_e90xa_29{padding:9px 8px}._rowCellInnerControls_e90xa_37{transition:.5s all ease;transform:translateY(0);display:block;transform-origin:left}._rowCellInnerControls_e90xa_37{position:absolute;top:50%;left:5px;transform:translateY(-50%)}._DataTableRow_actions_beneath_e90xa_61:hover ._rowCellInnerControls_e90xa_37{transform:translateY(0) scale(.8);top:4px}._DataTableRow_actions_over_e90xa_69:hover ._rowCellInnerControls_e90xa_37{opacity:0}._TableSort__btn_e90xa_75{opacity:0;transition:.5s all ease}._TableSort__btn_active_e90xa_83,._TableSort_e90xa_75:hover ._TableSort__btn_e90xa_75{opacity:1}._dtactions_1taex_1{height:22px;bottom:4px;display:flex;justify-content:flex-start;z-index:10}._dtactions_1taex_1 ._dtactions__actions_1taex_8{opacity:1;justify-content:flex-start;visibility:visible}._SearchResult_1uw6b_1{position:absolute;top:100%;left:0;z-index:1001;width:100%;max-height:378px;overflow:auto;padding:var(--size-step) 0;background-color:#fff;box-sizing:border-box;box-shadow:var(--box-shadow)}._SearchNoResult_1uw6b_15{bottom:0;position:sticky;left:0;margin-top:var(--size-step);margin-bottom:var(--size-step);background:#fff}._filter_close_o8fvt_1{position:absolute;top:50%;right:calc(var(--size-step) * 2);transform:translateY(-50%)}._filter_search_input_1rpsv_1{outline:none;border:none;font-size:14px}._filter_search_input_1rpsv_1::placeholder{color:var(--color-gray-500)}._filter_search_input_1rpsv_1:-ms-input-placeholder{color:var(--color-gray-500)}._filter_search_input_1rpsv_1::-ms-input-placeholder{color:var(--color-gray-500)}._filter_search_loader_1rpsv_16{position:absolute;right:5px;top:50%;transform:translateY(-50%)}

package/dist/dictionary.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./dataTableStoreFactory-BTH4XExR.cjs");exports.DictInput=t.DictInput;exports.useDictionary=t.useDictionary;exports.useDictionaryItems=t.useDictionaryItems;

package/dist/dictionary.d.ts

@@ -0,0 +1,2 @@
+export * from './src/modules/dictionary/index'
+export {}

package/dist/dictionary.js

@@ -0,0 +1,6 @@
+import { b as a, u as e, e as i } from "./dataTableStoreFactory-CTIqHKTT.js";
+export {
+  a as DictInput,
+  e as useDictionary,
+  i as useDictionaryItems
+};

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./dataTableStoreFactory-BTH4XExR.cjs");exports.DataTable=e.DataTable;exports.DataTableSkeleton=e.DataTable_skeleton;exports.DictInput=e.DictInput;exports.FilterBar=e.FilterBar;exports.FilterFormField=e.FilterFormField;exports.SearchAnything=e.SearchAnything;exports.TableActionCol=e.TableActionCol;exports.createDataTable=e.createDataTable;exports.makePaginatedFilterParams=e.makePaginatedFilterParams;exports.sortByField=e.sortByField;exports.useDictionary=e.useDictionary;exports.useDictionaryItems=e.useDictionaryItems;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/index'
+export {}

package/dist/index.js

@@ -0,0 +1,15 @@
+import { D as s, a as t, b as i, F as r, c as l, S as o, T as n, d as c, m as D, s as F, u as m, e as b } from "./dataTableStoreFactory-CTIqHKTT.js";
+export {
+  s as DataTable,
+  t as DataTableSkeleton,
+  i as DictInput,
+  r as FilterBar,
+  l as FilterFormField,
+  o as SearchAnything,
+  n as TableActionCol,
+  c as createDataTable,
+  D as makePaginatedFilterParams,
+  F as sortByField,
+  m as useDictionary,
+  b as useDictionaryItems
+};

package/dist/search.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./dataTableStoreFactory-BTH4XExR.cjs");exports.SearchAnything=e.SearchAnything;

package/dist/search.d.ts

@@ -0,0 +1,2 @@
+export * from './src/modules/search/index'
+export {}

package/dist/search.js

@@ -0,0 +1,4 @@
+import { S as e } from "./dataTableStoreFactory-CTIqHKTT.js";
+export {
+  e as SearchAnything
+};

package/dist/src/config/tests/changeDateField.d.ts

@@ -0,0 +1,2 @@
+export declare const changeDateField: (field: HTMLElement) => Promise<void>;
+export declare const changePeriodField: (field: HTMLElement) => Promise<void>;

package/dist/src/config/tests/changeSelectField.d.ts

@@ -0,0 +1 @@
+export declare const changeSelectField: (field: HTMLElement, label?: string) => Promise<void>;

package/dist/src/config/tests/changeTextField.d.ts

@@ -0,0 +1 @@
+export declare const changeTextField: (field: HTMLElement, value: string | number | boolean) => Promise<void>;

package/dist/src/config/tests/clickBackdropOverlay.d.ts

@@ -0,0 +1 @@
+export declare const clickBackdropOverlay: (container: Element) => Promise<void>;

package/dist/src/config/tests/createWrapper.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { Scope } from 'effector';
+export declare const renderWithScope: (ui: ReactNode, scope?: Scope) => import('@testing-library/react').RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;
+export declare function createWrapper(scope: Scope): ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './modules/table';
+export * from './modules/dictionary';
+export { SearchAnything, type SearchAnythingProps } from './modules/search/Search';

package/dist/src/modules/dictionary/config/types.d.ts

@@ -0,0 +1 @@
+export type GetDataArg = () => Promise<any>;

package/dist/src/modules/dictionary/index.d.ts

@@ -0,0 +1,3 @@
+export { useDictionaryItems } from './lib/useDictionaryItems';
+export { useDictionary } from './lib/useDictionary';
+export { DictInput } from './ui/DictInput';

package/dist/src/modules/dictionary/lib/useDictionary.d.ts

@@ -0,0 +1,7 @@
+import { GetDataArg } from '../config/types';
+type ReturnType = {
+    isFetching: boolean;
+    items: any[];
+};
+export declare function useDictionary<T extends Record<string, any> = Record<string, any>>(code: string, getData: GetDataArg): ReturnType;
+export {};

package/dist/src/modules/dictionary/lib/useDictionaryFetching.d.ts

@@ -0,0 +1 @@
+export declare function useDictionaryFetching(code: string): boolean;

package/dist/src/modules/dictionary/lib/useDictionaryItems.d.ts

@@ -0,0 +1 @@
+export declare function useDictionaryItems<T extends Record<string, any>>(code: string): any[];

package/dist/src/modules/dictionary/lib/useDictionaryRequested.d.ts

@@ -0,0 +1 @@
+export declare const useDictionaryRequested: (code: string) => boolean;

package/dist/src/modules/dictionary/model/dictionaryStore.d.ts

@@ -0,0 +1,19 @@
+import { DataTableGetListType } from '../../table';
+import { GetDataArg } from '../config/types';
+type SingleDictionaryStore = {
+    code: string;
+    getData: () => Promise<any>;
+    requested: boolean;
+    isFetching: boolean;
+    items: any[];
+};
+export declare const $dictionaries: import('effector').StoreWritable<Record<string, SingleDictionaryStore>>;
+export declare const dictDataFetched: import('effector').EventCallable<{
+    code: string;
+    getData: GetDataArg;
+} & DataTableGetListType>;
+export declare const fetchDictionaryDataFx: import('effector').Effect<{
+    getData: () => Promise<any>;
+    code: string;
+} & DataTableGetListType, any, Error>;
+export {};

package/dist/src/modules/dictionary/ui/DictInput.d.ts

@@ -0,0 +1,10 @@
+import { ComponentProps, ElementType } from 'react';
+type Props<E extends ElementType = ElementType> = {
+    getData: () => Promise<any>;
+    code: string;
+    value_key?: string;
+    label_key?: string;
+    Component: E;
+} & ComponentProps<E>;
+export declare function DictInput<E extends ElementType>(props: Omit<Props<E>, 'options'>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/modules/search/Search.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { TextFieldProps } from 'armtek-uikit-react/ui/Form/TextField';
+export type SearchAnythingProps<T extends Record<string, any>> = {
+    getData: () => Promise<any>;
+    code: string;
+    endpoint: string | ((value: string) => string);
+    getValue?: (item: T) => string | ReactNode;
+    getOption?: (item: T) => string | ReactNode;
+    getTitle?: (item: T) => string;
+    noResultNode?: string | ReactNode;
+    defaultValue?: string;
+    onSelect?: (value: string, item: T) => void;
+    onChange?: (value: string) => void;
+    onReset?: () => void;
+    onClickAway?: () => void;
+    recommendations?: T[];
+    label__recommendations?: string;
+    inputProps?: TextFieldProps;
+    value?: string;
+};
+export declare function SearchAnything<T extends Record<string, any>>(props: SearchAnythingProps<T> & Omit<TextFieldProps, keyof SearchAnythingProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/src/modules/search/index.d.ts

@@ -0,0 +1 @@
+export { SearchAnything, type SearchAnythingProps } from './Search';

package/dist/src/modules/table/index.d.ts

@@ -0,0 +1,11 @@
+export { DataTable } from './model/dataTableContext';
+export { createDataTable } from './model/dataTableStoreFactory';
+export { type DataTableColType, type TableRowType2 } from './ui/DataTable';
+export { type FilterItemType, FilterBar } from './ui/FilterBar/FilterBar';
+export { FilterFormField } from './ui/FilterBar/FilterForm/FilterFormField';
+export { default as DataTableSkeleton } from './ui/DataTable.skeleton';
+export { sortByField } from './lib/sortByField';
+export { type TableContextActionType } from './ui/TableContextMenu';
+export { type TableRowActionType } from './ui/Table/Table';
+export { TableActionCol } from './ui/TableActionCol';
+export { makePaginatedFilterParams, type DataTableGetListType } from './lib/makePaginatedFilterParams';

package/dist/src/modules/table/lib/GetDefaultFilters.d.ts

@@ -0,0 +1,2 @@
+import { FilterItemType } from '../ui/FilterBar/FilterBar';
+export declare const getDefaultFilters: (filters: FilterItemType<any>[]) => FilterItemType<any>[];

package/dist/src/modules/table/lib/const.d.ts

@@ -0,0 +1 @@
+export declare const DATA_TABLE_PAGE_SIZES: number[];

package/dist/src/modules/table/lib/deleteUrlParamByName.d.ts

@@ -0,0 +1 @@
+export declare const deleteUrlParamByName: (name: string, url: string) => string;

package/dist/src/modules/table/lib/formatDate.d.ts

@@ -0,0 +1,3 @@
+type DateInput = string | Date;
+export declare const formatDate: (date: DateInput, format?: string) => string;
+export {};

package/dist/src/modules/table/lib/getFilterDisplayValue.d.ts

@@ -0,0 +1,3 @@
+import { FilterItemType } from '../ui/FilterBar/FilterBar';
+import { TableRowType2 } from '../ui/DataTable';
+export declare const getFilterDisplayValue: <T extends TableRowType2>(item: FilterItemType<T>, value: any, config?: Record<string, any>) => string;

package/dist/src/modules/table/lib/local_storage.d.ts

@@ -0,0 +1,6 @@
+export declare const LocalStorage: {
+    getArray<R = any>(key: string): R[];
+    setItem(key: string, value: any): void;
+    getItem(key: string): string | null;
+    pushValue<R = any>(key: string, value: R, limit?: number, id_key?: keyof R | null, unique?: boolean): void;
+};

package/dist/src/modules/table/lib/makePaginatedFilterParams.d.ts

@@ -0,0 +1,12 @@
+import { SortOrderType } from '../model/types';
+import { FilterItemType } from '../ui/FilterBar/FilterBar';
+export type DataTableGetListType = {
+    searchFields?: string[];
+    searchQuery?: string;
+    filter?: FilterItemType[];
+    page?: number | string;
+    pageSize?: number;
+    sort?: string | null;
+    order?: SortOrderType;
+};
+export declare function makePaginatedFilterParams(config: DataTableGetListType): URLSearchParams;

package/dist/src/modules/table/lib/sortByField.d.ts

@@ -0,0 +1,3 @@
+import { SortOrderType } from '../model/types';
+import { TableRowType2 } from '../ui/DataTable';
+export declare const sortByField: (field: string, order?: SortOrderType) => (a: TableRowType2, b: TableRowType2) => any;

package/dist/src/modules/table/lib/uuid.d.ts

@@ -0,0 +1 @@
+export declare const uuidv4: () => string;

package/dist/src/modules/table/model/dataTableContext.d.ts

@@ -0,0 +1,36 @@
+import { MouseEvent, ReactNode } from 'react';
+import { SortOrderType } from './types';
+import { FilterItemType } from '../ui/FilterBar/FilterBar';
+import { DataTableActionType } from '../ui/TableActionBar/DataTableActionBar';
+import { TableRowActionType } from '../ui/Table/Table';
+import { TableContextActionType } from '../ui/TableContextMenu';
+import { DataTableColType, TableRowType2 } from '../ui/DataTable';
+import { DataTableCombinedStore } from './dataTableStoreFactory';
+export declare const DataTableContext: import('react').Context<any>;
+type DataTableProps<T extends TableRowType2> = {
+    endpoint?: string;
+    items?: T[];
+    filters?: FilterItemType<T>[];
+    structure?: DataTableColType<T>[];
+    tableActions?: DataTableActionType<T>[];
+    rowActions?: TableRowActionType<T>[];
+    contextActions?: TableContextActionType<T>[];
+    onActionClick?: (row: T, code: string) => void;
+    onContextMenu?: (e: MouseEvent<any>, row: T) => void;
+    onRowClick?: (e: MouseEvent, row: T) => void;
+    displayActionCol?: boolean;
+    displaySummary?: boolean;
+    displayIndex?: boolean;
+    sort?: keyof T;
+    order?: SortOrderType;
+    page?: number;
+    pageSize?: number;
+    emptyResult?: string | ReactNode;
+    getIsRowActive?: (row: T) => boolean;
+    getRowStyles?: (row: T) => any;
+    search?: Array<keyof T>;
+    rowClassName?: ((row: T) => string) | string;
+    store: DataTableCombinedStore;
+};
+export declare function DataTable<T extends TableRowType2>(props: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/modules/table/model/dataTableStoreFactory.d.ts

@@ -0,0 +1,97 @@
+import { DataTableColType, TableRowType2 } from '../ui/DataTable';
+import { SortOrderType } from './types';
+import { Effect, EventCallable, StoreWritable } from 'effector';
+import { FilterItemType } from '../ui/FilterBar/FilterBar';
+import { DataTableActionType } from '../ui/TableActionBar/DataTableActionBar';
+import { TableContextActionType } from '../ui/TableContextMenu';
+import { TableRowActionType } from '../ui/Table/Table';
+type Page = number;
+type PageSize = number;
+type Sort = string;
+type Endpoint = string;
+type SearchQuery = string;
+type SearchFields = string[];
+type GetResults = (result: any) => any[];
+type GetCount = (result: any) => number;
+type Mapper = (item: any) => any;
+type FetchArgs = {
+    endpoint: Endpoint;
+    currentFilter: FilterItemType<any>[];
+    page: Page;
+    pageSize: PageSize;
+    sort: Sort;
+    order: SortOrderType;
+    searchQuery: SearchQuery;
+    searchFields: SearchFields;
+    local: boolean;
+};
+type DataTableInitialValues = {
+    getData: (url: string) => Promise<any[]>;
+    endpoint: string;
+    structure?: DataTableColType<any>[];
+    pageSize?: PageSize;
+    page?: Page;
+    filters?: FilterItemType<any>[];
+    items?: TableRowType2[];
+    count?: number;
+    enableRowClick?: boolean;
+    local?: boolean;
+    displayIndex?: boolean;
+    displayActionCol?: boolean;
+    tableActions?: DataTableActionType<any>[];
+    contextActions?: TableContextActionType<any>[];
+    rowActions?: TableRowActionType<any>[];
+    sort?: Sort;
+    order?: SortOrderType;
+    search?: string[];
+    getResult?: GetResults;
+    getCount?: GetCount;
+    mapper?: Mapper;
+    cacheTime?: number;
+};
+export type DataTableCombinedStore = {
+    dataTableInitialized: EventCallable<DataTableInitialValues>;
+    itemsSet: EventCallable<{
+        items: TableRowType2[];
+        applyFilters?: boolean;
+    }>;
+    dataFetched: EventCallable<void>;
+    searchQuerySet: EventCallable<string>;
+    currentFilterDeleted: EventCallable<string>;
+    currentFilterSet: EventCallable<FilterItemType>;
+    rowsSelected: EventCallable<{
+        rows: string[];
+        flag: boolean;
+    }>;
+    sortSet: EventCallable<string>;
+    pageSet: EventCallable<number>;
+    pageSizeSet: EventCallable<number>;
+    itemAdded: EventCallable<TableRowType2>;
+    itemUpdated: EventCallable<TableRowType2>;
+    itemDeleted: EventCallable<string>;
+    $endpoint: StoreWritable<string>;
+    $tableActions: StoreWritable<DataTableActionType<any>[]>;
+    $isReady: StoreWritable<boolean>;
+    $items: StoreWritable<TableRowType2[]>;
+    $search: StoreWritable<string[]>;
+    $filters: StoreWritable<FilterItemType[]>;
+    $currentFilter: StoreWritable<FilterItemType[]>;
+    $searchQuery: StoreWritable<string>;
+    $isFetching: StoreWritable<boolean>;
+    $sort: StoreWritable<string>;
+    $order: StoreWritable<SortOrderType>;
+    $displayActionCol: StoreWritable<boolean>;
+    $displayIndex: StoreWritable<boolean>;
+    $local: StoreWritable<boolean>;
+    $structure: StoreWritable<DataTableColType<any>[]>;
+    $pageSize: StoreWritable<number>;
+    $page: StoreWritable<number>;
+    $count: StoreWritable<number>;
+    $requested: StoreWritable<boolean>;
+    $rowActions: StoreWritable<TableRowActionType<any>[]>;
+    $contextActions: StoreWritable<TableContextActionType<any>[]>;
+    fetchDataFx: Effect<FetchArgs, any>;
+};
+type DataTableFactory = (args: DataTableInitialValues) => DataTableCombinedStore;
+export declare const createDataTable: DataTableFactory;
+export {};

package/dist/src/modules/table/model/types.d.ts

@@ -0,0 +1,22 @@
+export type SortOrderType = 'asc' | 'desc';
+export type apiMatchModeType = 'range' | 'date' | 'iexact' | 'exact' | 'icontains' | 'contains' | 'isnull' | 'in' | 'id' | 'gt' | 'lt' | 'gte' | 'lte' | 'interval';
+export type FilterObjectItemType = {
+    type: 'string' | 'select' | 'period' | 'checkbox' | 'date_period';
+    matchMode?: apiMatchModeType;
+    is_numeric?: boolean;
+    value: any;
+    displayValue?: string;
+    label?: string;
+};
+export type GetListResponseType<T = any> = {
+    count: number;
+    previous: string | null;
+    next: string | null;
+    results: Array<T>;
+};
+export type DictType<T extends {
+    [key: string]: any;
+} = Record<string, any>> = {
+    id: string;
+    name: string;
+} & T;

package/dist/src/modules/table/model/useDataTable.d.ts

@@ -0,0 +1,2 @@
+import { DataTableCombinedStore } from './dataTableStoreFactory';
+export declare const useDataTable: () => DataTableCombinedStore;

package/dist/src/modules/table/ui/ActionList/ActionList.d.ts

@@ -0,0 +1,13 @@
+export type ActionListItemType = {
+    label: string;
+    value?: string;
+    onClick?: (item: ActionListItemType) => void;
+};
+type PropsType = {
+    minWidth?: string;
+    wrapperClassName?: string;
+    items: ActionListItemType[];
+    onButtonClick?: (item: ActionListItemType) => void;
+};
+export declare const ActionList: (props: PropsType) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/modules/table/ui/DataTable.d.ts

@@ -0,0 +1,54 @@
+import { FilterItemType } from './FilterBar/FilterBar';
+import { DataTableActionType } from './TableActionBar/DataTableActionBar';
+import { MouseEvent, ReactNode } from 'react';
+import { TableRowActionType } from './Table/Table';
+import { SortOrderType } from '../model/types';
+import { TableContextActionType } from './TableContextMenu';
+export type TableRowType2<T = {
+    [key: string]: any;
+}> = {
+    dt_selected?: boolean;
+    dt_hidden?: boolean;
+    dt_id?: string;
+} & T;
+export type DataTableColType<T extends TableRowType2> = {
+    id: string | keyof T;
+    label: string;
+    sort?: boolean;
+    getValue?: (row: T) => ReactNode | string;
+    getTitle?: () => ReactNode | string;
+    getSum?: (rows: T[]) => string | number;
+    is_numeric?: boolean;
+    displayActions?: boolean;
+    style?: Record<string, any>;
+    className?: string | ((row: T) => string);
+};
+export declare const mapDataTableResult: (result: TableRowType2[]) => TableRowType2[];
+type PropsType<T extends TableRowType2> = {
+    local?: boolean;
+    endpoint?: string;
+    items?: T[];
+    uniqueKey?: keyof T | string;
+    filters?: FilterItemType<T>[];
+    structure?: DataTableColType<T>[];
+    tableActions?: DataTableActionType<T>[];
+    rowActions?: TableRowActionType<T>[];
+    contextActions?: TableContextActionType<T>[];
+    onActionClick?: (row: T, code: string) => void;
+    onContextMenu?: (e: MouseEvent<any>, row: T) => void;
+    onRowClick?: (e: MouseEvent, row: T) => void;
+    displayActionCol?: boolean;
+    displaySummary?: boolean;
+    displayIndex?: boolean;
+    sort?: keyof T;
+    order?: SortOrderType;
+    page?: number;
+    pageSize?: number;
+    emptyResult?: string | ReactNode;
+    getIsRowActive?: (row: T) => boolean;
+    getRowStyles?: (row: T) => any;
+    search?: Array<keyof T>;
+    rowClassName?: ((row: T) => string) | string;
+};
+export declare function DataTableInner<T extends TableRowType2>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/src/modules/table/ui/DataTable.skeleton.d.ts

@@ -0,0 +1,12 @@
+import { DataTableColType } from './DataTable';
+export declare const DataTableFilterSkeleton: () => import("react/jsx-runtime").JSX.Element;
+type DTBodyPropsType = {
+    structure: DataTableColType<any>[];
+    pageSize: number;
+    useSelection?: boolean;
+    useIndexes?: boolean;
+    useActionCol?: boolean;
+};
+export declare const TableBodySkeleton: (props: DTBodyPropsType) => import("react/jsx-runtime").JSX.Element;
+declare const _default: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export default _default;

package/dist/src/modules/table/ui/DataTableActions/DataTableActions.d.ts

@@ -0,0 +1,6 @@
+import { ActionListItemType } from '../ActionList/ActionList';
+type TableActionsProps = {
+    actions: ActionListItemType[];
+};
+export declare const TableActions: (props: TableActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/modules/table/ui/FilterBar/FilterBar.d.ts

@@ -0,0 +1,71 @@
+import { apiMatchModeType } from '../../model/types';
+import { TableRowType2 } from '../DataTable';
+import { StringFilterType } from './FilterForm/FilterFormInput';
+import { SelectFilterType } from './FilterForm/FilterFormSelect';
+import { DateFilterType } from './FilterForm/FilterFormDate';
+import { PeriodFilterType } from './FilterForm/FilterFormPeriod';
+import { CheckboxFilterType } from './FilterForm/FilterFormCheckbox';
+import { SearchFilterType } from './FilterForm/FilterFormSearch';
+import { IntervalFilterType } from './FilterForm/FilterFormInterval';
+type FilterValueType = {
+    value: any;
+    displayValue?: string;
+    matchMode: apiMatchModeType;
+};
+type FilterAND = {
+    [key: string]: FilterValueType;
+};
+type FilterOR = FilterAND;
+type FilterSUB = {
+    sys_name: FilterValueType;
+    value: FilterValueType;
+    sub_values_list: string;
+    sub_app: string;
+    sub_model: string;
+};
+type AsyncFilterReturnType = {
+    and: FilterAND;
+    or: FilterOR;
+    sub: FilterSUB[];
+};
+export declare const makeAsyncFilter: (filters: FilterItemType[], searchFields?: string[], searchQuery?: string) => AsyncFilterReturnType | false;
+export declare function applyFilters<T extends TableRowType2>(items: T[], filters: FilterItemType[], searchFields?: Array<keyof T>, query?: string): TableRowType2<T>[];
+export interface ButtonFilterType<T extends TableRowType2 = TableRowType2> extends FilterType<T> {
+    type: 'button';
+    value: string | number;
+    getDisplayValue?: (item: ButtonFilterType, value: string) => string;
+}
+export type FilterItemType<T extends TableRowType2 = TableRowType2> = StringFilterType<T> | SelectFilterType<T> | DateFilterType<T> | PeriodFilterType<T> | CheckboxFilterType<T> | SearchFilterType<T> | ButtonFilterType<T> | IntervalFilterType<T>;
+type LogicType = 'and' | 'sub';
+export interface FilterType<T extends TableRowType2 = TableRowType2> {
+    code: keyof T | string;
+    compareKey?: string | keyof T;
+    label: string;
+    matchMode?: apiMatchModeType;
+    active?: boolean;
+    hidden?: boolean;
+    displayValue?: string;
+    logic?: LogicType;
+    getValid?: (row: T, f: FilterItemType) => boolean;
+    getDisplayValue?: (item: any, value: any) => string;
+    getCompareValue?: (row: T) => string;
+    type: 'string' | 'period' | 'checkbox' | 'search' | 'select' | 'filter' | 'date' | 'button' | 'interval';
+    subLogic?: {
+        sub_app: string;
+        sub_model: string;
+        sub_values_list: string;
+    };
+}
+export type FilterBarPropsType<T extends TableRowType2> = {
+    items: FilterItemType<T>[];
+    searchItems?: Array<keyof T>;
+    selected?: FilterItemType<T>[];
+    onSubmit?: (item: FilterItemType<any>, value: any, displayValue: string) => void;
+    onDelete?: (code: string) => void;
+    onSearch?: (value: string) => void;
+    onChange?: (filters: FilterItemType<any>[]) => void;
+    searchDelay?: number;
+    searchQuery?: string;
+};
+export declare function FilterBar<T extends TableRowType2>(props: FilterBarPropsType<T>): import("react/jsx-runtime").JSX.Element;
+export default FilterBar;

package/dist/src/modules/table/ui/FilterBar/FilterForm/FilterForm.d.ts

@@ -0,0 +1,9 @@
+import { FilterItemType } from '../FilterBar';
+import { TableRowType2 } from '../../DataTable';
+type PropsType<T extends TableRowType2> = {
+    filter: FilterItemType<T>;
+    onClose: () => void;
+    onSubmit: (value: any, displayValue: string) => void;
+};
+declare function FilterForm<T extends TableRowType2>(props: PropsType<T>): import("react/jsx-runtime").JSX.Element;
+export default FilterForm;

package/dist/src/modules/table/ui/FilterBar/FilterForm/FilterFormCheckbox.d.ts

@@ -0,0 +1,24 @@
+import { FilterType } from '../FilterBar';
+import { TableRowType2 } from '../../DataTable';
+import { OptionType } from 'armtek-uikit-react/ui/Form/Select';
+export interface CheckboxFilterType<T extends TableRowType2> extends FilterType<T> {
+    type: 'checkbox';
+    value?: string[];
+    options: OptionType[];
+    getValue?: (value: string) => any;
+    getDisplayValue?: (item: CheckboxFilterType<any>, value: string[]) => string;
+    multiple?: boolean;
+    async?: {
+        endpoint: string;
+        valueKey?: string;
+        labelKey?: string;
+    };
+}
+type PropsType = {
+    item: CheckboxFilterType<any>;
+    onChange: (value: string[], displayValue: string) => void;
+    value: string[];
+    options: OptionType[];
+};
+declare const CheckboxFilterContainer: (props: PropsType) => import("react/jsx-runtime").JSX.Element;
+export default CheckboxFilterContainer;

package/dist/src/modules/table/ui/FilterBar/FilterForm/FilterFormDate.d.ts

@@ -0,0 +1,16 @@
+import { FilterType } from '../FilterBar';
+import { TableRowType2 } from '../../DataTable';
+export interface DateFilterType<T extends TableRowType2> extends FilterType<T> {
+    type: 'date';
+    variant?: 'date' | 'datetime';
+    value?: Date | null;
+    getDisplayValue?: (item: DateFilterType<any>, date: Date) => string;
+    getValue?: (value: Date) => string;
+}
+type PropsType = {
+    item: DateFilterType<any>;
+    onChange: (value: Date, displayValue: string) => void;
+    value: Date;
+};
+declare const FilterFormDate: (props: PropsType) => import("react/jsx-runtime").JSX.Element;
+export default FilterFormDate;

package/dist/src/modules/table/ui/FilterBar/FilterForm/FilterFormField.d.ts

@@ -0,0 +1,10 @@
+import { FilterItemType } from '../FilterBar';
+type PropsType = {
+    item: FilterItemType<any>;
+    onChange: (value: any, displayValue: string) => void;
+    value: any;
+    error?: string;
+    clear?: boolean;
+};
+export declare const FilterFormField: (props: PropsType) => import("react/jsx-runtime").JSX.Element;
+export default FilterFormField;