@e-burgos/tucu-ui 2.5.0 → 2.6.0

package/datatable/components/DataTable/TableCell/index.d.ts

@@ -0,0 +1,44 @@
+import { default as React } from 'react';
+import { Cell, ColumnDef, Row, Table } from '@tanstack/react-table';
+import { HoverType, IRowActions, IRowSelection, TData } from '../../../common/types';
+/**
+ * Props for the TableCell component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {string} tableId - The id of the table.
+ * @property {Table<TData>} table - The table instance.
+ * @property {Cell<TData, unknown>} cell - The cell instance.
+ * @property {Row<TData>} row - The row instance.
+ * @property {HoverType} hoverRow - The hover row instance.
+ * @property {Array<IRowActions<TData>>} rowActions - The row actions.
+ * @property {React.CSSProperties} style - The style of the cell.
+ * @property {function(HoverType): void} setHoverRow - The function to set the hover row.
+ * @property {function(boolean): void} setOpenActions - The function to set the open actions.
+ * @property {boolean} forceShowMenuActions - Whether to force show the menu actions.
+ * @property {IRowSelection<TData>} rowSelection - The row selection.
+ *
+ * @template TData - The type of the data in the table.
+ */
+export type ColumnDefWithAccessor<TData> = ColumnDef<TData, unknown> & {
+    accessorFn?: (row: TData) => unknown;
+    exportAsNumber?: boolean;
+    exportAsPercentage?: boolean;
+    hasSubTable?: boolean;
+};
+interface TableCellProps {
+    tableId: string;
+    table: Table<TData>;
+    row: Row<TData>;
+    cell: Cell<TData, unknown>;
+    hoverRow: HoverType;
+    rowActions?: IRowActions<TData>[];
+    style?: React.CSSProperties;
+    forceShowMenuActions?: boolean;
+    rowSelection?: IRowSelection<TData>;
+    setHoverRow: (value: HoverType) => void;
+    setOpenActions?: (value: boolean) => void;
+}
+declare const _default: React.NamedExoticComponent<TableCellProps>;
+export default _default;

package/datatable/components/DataTable/TableHead/index.d.ts

@@ -0,0 +1,33 @@
+import { ColumnOrderState, Table } from '@tanstack/react-table';
+import { IDataTableStyles, IHeaderOptions } from '../../../common/types';
+/**
+ * Props for the TableHead component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {IDataTableStyles} sx - The styles for the table head.
+ * @property {string} tableId - The id of the table.
+ * @property {Table<TData>} table - The table instance.
+ * @property {Array<TData>} data - The data to be displayed in the table.
+ * @property {ColumnOrderState} columnOrder - The order of the columns.
+ * @property {boolean} smallAnatomy - Whether the table is in small anatomy mode.
+ * @property {IHeaderOptions} headerOptions - The options for the header.
+ * @property {boolean} disabled - Whether the table is disabled.
+ * @property {function(boolean): void} setHoverColumns - The function to set the hover columns.
+ *
+ * @template TData - The type of the data in the table.
+ */
+export interface TableHeadProps<TData> {
+    sx?: IDataTableStyles;
+    tableId: string;
+    table: Table<TData>;
+    data: TData[];
+    columnOrder: ColumnOrderState;
+    smallAnatomy?: boolean;
+    headerOptions?: IHeaderOptions;
+    disabled?: boolean;
+    setHoverColumns: (value: boolean) => void;
+}
+declare function TableHead<TData>({ sx, tableId, table, columnOrder, smallAnatomy, headerOptions, disabled, setHoverColumns, }: TableHeadProps<TData>): import("react/jsx-runtime").JSX.Element;
+export default TableHead;

package/datatable/components/DataTable/TableHeader/CheckboxSelector/index.d.ts

@@ -0,0 +1,17 @@
+import { HTMLProps } from 'react';
+/**
+ * Props for the CheckboxSelector component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {boolean} indeterminate - Whether the checkbox is indeterminate.
+ * @property {string} className - The class name of the checkbox.
+ * @property {HTMLProps<HTMLInputElement>} rest - The rest of the props.
+ *
+ * @template TData - The type of the data in the table.
+ */
+declare function CheckboxSelector({ indeterminate, className, ...rest }: {
+    indeterminate?: boolean;
+} & HTMLProps<HTMLInputElement>): import("react/jsx-runtime").JSX.Element;
+export default CheckboxSelector;

package/datatable/components/DataTable/TableHeader/ColumnDraggable/index.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { DraggableAttributes } from '@dnd-kit/core';
+import { SyntheticListenerMap } from '@dnd-kit/core/dist/hooks/utilities';
+/**
+ * Props for the ColumnDraggable component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {string} color - The color of the column.
+ * @property {DraggableAttributes} attributes - The attributes of the column.
+ * @property {SyntheticListenerMap} listeners - The listeners of the column.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface ColumnDraggableProps {
+    color?: string;
+    attributes: DraggableAttributes;
+    listeners: SyntheticListenerMap;
+}
+declare const ColumnDraggable: React.FC<ColumnDraggableProps>;
+export default ColumnDraggable;

package/datatable/components/DataTable/TableHeader/ColumnPin/index.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { Header } from '@tanstack/react-table';
+import { TData } from '../../../../common/types';
+/**
+ * Props for the ColumnPin component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {Header<TData, unknown>} header - The header of the column.
+ * @property {boolean} disabled - Whether the column is disabled.
+ * @property {string} color - The color of the column.
+ * @property {boolean} enablePinLeftColumns - Whether the column can be pinned to the left.
+ * @property {boolean} enablePinRightColumns - Whether the column can be pinned to the right.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface ColumnPinProps {
+    header: Header<TData, unknown>;
+    disabled?: boolean;
+    color?: string;
+    enablePinLeftColumns?: boolean;
+    enablePinRightColumns?: boolean;
+}
+declare const ColumnPin: React.FC<ColumnPinProps>;
+export default ColumnPin;

package/datatable/components/DataTable/TableHeader/ColumnSearcher/InputSearcher.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+/**
+ * Props for the InputSearcher component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {string} value - The value of the input.
+ * @property {function(string): void} onChange - The function to call when the input value changes.
+ * @property {number} debounce - The debounce time for the input.
+ *
+ * @template TData - The type of the data in the table.
+ */
+declare function InputSearcher({ value: initialValue, onChange, debounce, ...props }: {
+    value: string | number;
+    onChange: (value: string | number) => void;
+    debounce?: number;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'>): import("react/jsx-runtime").JSX.Element;
+export default InputSearcher;

package/datatable/components/DataTable/TableHeader/ColumnSearcher/index.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { Column } from '@tanstack/react-table';
+import { TData } from '../../../../common/types';
+/**
+ * Props for the ColumnSearcher component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {Column<TData, TData>} column - The column to search.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface ColumnSearcherProps {
+    column: Column<TData, TData>;
+}
+declare const ColumnSearcher: React.FC<ColumnSearcherProps>;
+export default ColumnSearcher;

package/datatable/components/DataTable/TableHeader/ColumnSort/index.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { Header } from '@tanstack/react-table';
+import { TData } from '../../../../common/types';
+/**
+ * Props for the ColumnSort component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {Header<TData, unknown>} header - The header of the column.
+ * @property {boolean} isPinned - Whether the column is pinned.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface ColumnSortProps {
+    header: Header<TData, unknown>;
+    isPinned?: boolean;
+}
+declare const ColumnSort: React.FC<ColumnSortProps>;
+export default ColumnSort;

package/datatable/components/DataTable/TableHeader/ColumnVisibility/index.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { Header } from '@tanstack/react-table';
+import { TData } from '../../../../common/types';
+/**
+ * Props for the ColumnVisibility component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {Header<TData, unknown>} header - The header of the column.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface ColumnVisibilityProps {
+    header: Header<TData, unknown>;
+}
+declare const ColumnVisibility: React.FC<ColumnVisibilityProps>;
+export default ColumnVisibility;

package/datatable/components/DataTable/TableHeader/index.d.ts

@@ -0,0 +1,30 @@
+import { Header } from '@tanstack/react-table';
+import { IHeaderOptions, TData } from '../../../common/types';
+/**
+ * Props for the TableHeader component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {Header<TData, unknown>} header - The header of the column.
+ * @property {HeaderGroup<TData>} headerGroup - The header group of the column.
+ * @property {number} index - The index of the column.
+ * @property {IHeaderOptions} headerOptions - The header options of the column.
+ * @property {boolean} disabled - Whether the column is disabled.
+ * @property {boolean} isHeaderFixed - Whether the header is fixed.
+ * @property {React.CSSProperties} style - The style of the column.
+ * @property {string} tableId - The id of the table.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface TableHeaderProps {
+    header: Header<TData, unknown>;
+    index: number;
+    headerOptions?: IHeaderOptions;
+    disabled?: boolean;
+    isHeaderFixed?: boolean;
+    style?: React.CSSProperties;
+    tableId: string;
+}
+declare const _default: import('react').NamedExoticComponent<TableHeaderProps>;
+export default _default;

package/datatable/components/DataTable/TableRow/index.d.ts

@@ -0,0 +1,43 @@
+import { FC, CSSProperties } from 'react';
+import { Row, Table } from '@tanstack/react-table';
+import { IRowActions, IRowSelection, TData } from '../../../common/types';
+/**
+ * Props for the TableRow component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {string} tableId - The id of the table.
+ * @property {Table<TData>} table - The table instance.
+ * @property {Row<TData>} row - The row instance.
+ * @property {number} index - The index of the row.
+ * @property {Array<string>} columnOrder - The order of the columns.
+ * @property {CSSProperties} style - The style of the row.
+ * @property {boolean} isColumn - Whether the row is a column.
+ * @property {Array<IRowActions<TData>>} rowActions - The row actions.
+ * @property {function(React.MouseEvent<HTMLTableRowElement>): void} onClick - The function to call when the row is clicked.
+ * @property {boolean} forceShowMenuActions - Whether to force show the menu actions.
+ * @property {IRowSelection<TData>} rowSelection - The row selection.
+ * @property {boolean} smallAnatomy - Whether the row is a small anatomy.
+ *
+ * @template TData - The type of the data in the table.
+ */
+interface RowProps {
+    tableId: string;
+    table: Table<TData>;
+    row: Row<TData>;
+    index: number;
+    columnOrder: string[];
+    style?: {
+        row?: CSSProperties;
+        cell?: CSSProperties;
+    };
+    isColumn: boolean;
+    rowActions?: IRowActions<TData>[];
+    onClick: React.MouseEventHandler<HTMLTableRowElement>;
+    forceShowMenuActions?: boolean;
+    rowSelection: IRowSelection<TData>;
+    smallAnatomy?: boolean;
+}
+declare const TableRow: FC<RowProps>;
+export default TableRow;

package/datatable/components/DataTable/TableWrapper/index.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+import { IDataTableStyles } from '../../../common/types';
+/**
+ * Props for the TableWrapper component.
+ *
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @property {string} tableId - The id of the table.
+ * @property {string} title - The title of the table.
+ * @property {boolean} border - Whether the table has a border.
+ * @property {boolean} isFetching - Whether the table is fetching.
+ * @property {boolean} isEmpty - Whether the table is empty.
+ * @property {React.ReactNode} headerContainer - The header container of the table.
+ * @property {React.ReactNode} children - The children of the table.
+ * @property {IDataTableStyles} sx - The styles of the table.
+ * @property {number} containerWidth - The width of the table.
+ *
+ * @template TData - The type of the data in the table.
+ */
+export interface TableWrapperProps {
+    tableId: string;
+    title?: string;
+    border?: boolean;
+    isFetching?: boolean;
+    isEmpty?: boolean;
+    headerContainer?: React.ReactNode;
+    children: React.ReactNode;
+    sx?: IDataTableStyles;
+    containerWidth?: number;
+    mode?: 'dark' | 'light';
+}
+declare const TableWrapper: React.FC<TableWrapperProps>;
+export default TableWrapper;

package/datatable/components/DataTable/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DataTableComponent } from './DataTableComponent';
+export { default as DataTable } from './DataTable';
+export { default as ColumnsVisibilityManager } from './ColumnsVisibilityManager';

package/datatable/components/Footer/index.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { Table } from '@tanstack/react-table';
+import { TData } from '../../common/types';
+/**
+ * FooterProps
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @param className - The className
+ * @param sx - The sx
+ * @param table - The table
+ */
+interface FooterProps {
+    className?: string;
+    sx?: React.CSSProperties;
+    table: Table<TData>;
+}
+declare const Footer: React.FC<FooterProps>;
+export default Footer;

package/datatable/components/ManualPagination/index.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { IManualPaginationOptions } from '../../common/types';
+/**
+ * ManualPaginationProps
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @param manualPagination - The manualPagination
+ * @param hideRecordsSelector - The hideRecordsSelector
+ * @param rowsInfo - The rowsInfo
+ * @param style - The style
+ */
+interface ManualPaginationProps {
+    manualPagination?: IManualPaginationOptions;
+    hideRecordsSelector?: boolean;
+    rowsInfo?: boolean;
+    style?: React.CSSProperties;
+}
+declare const ManualPagination: React.FC<ManualPaginationProps>;
+export default ManualPagination;

package/datatable/components/Pagination/index.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { Table } from '@tanstack/react-table';
+import { TData, IPaginationOptions } from '../../common/types';
+/**
+ * PaginationProps
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @param tableId - The tableId
+ * @param table - The table
+ * @param pagination - The pagination
+ * @param style - The style
+ */
+interface PaginationProps {
+    tableId: string;
+    table: Table<TData>;
+    pagination?: IPaginationOptions;
+    style?: React.CSSProperties;
+}
+declare const Pagination: React.FC<PaginationProps>;
+export default Pagination;

package/datatable/components/RowSelection/index.d.ts

@@ -0,0 +1,14 @@
+import { HTMLProps } from 'react';
+/**
+ * RowSelectionProps
+ * @category libs/datatable
+ * @subcategory Components
+ *
+ * @param type - The type of the row selection (checkbox or radio)
+ * @param indeterminate - The indeterminate state of the row selection
+ * @param rest - The rest of the props
+ */
+export declare function RowSelection({ type, indeterminate, ...rest }: {
+    indeterminate?: boolean;
+    type?: 'checkbox' | 'radio';
+} & HTMLProps<HTMLInputElement>): React.JSX.Element;

package/datatable/context/DragDropContentContext.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+import { ColumnOrderState } from '@tanstack/react-table';
+/**
+ * Props for the DragDropContentContext component.
+ *
+ * @category libs/datatable
+ * @subcategory Context
+ *
+ * @property {React.ReactNode} children - The child nodes to render within the context.
+ * @property {ColumnOrderState} columnOrder - The order of the columns.
+ * @property {string} id - The id of the context.
+ */
+interface DragDropContentContextProps {
+    id?: string;
+    children: React.ReactNode;
+    columnOrder: ColumnOrderState;
+}
+/**
+ * DragDropContentContext is a React component that provides a drag and drop context for content.
+ * It utilizes the SortableContext from '@dnd-kit/sortable' with a horizontal sorting strategy.
+ *
+ * @category libs/datatable
+ * @subcategory Context
+ *
+ * @component
+ * @param {DragDropContentContextProps} props - The properties for the DragDropContentContext component.
+ * @param {React.ReactNode} props.children - The child nodes to render within the context.
+ * @param {ColumnOrderState} props.columnOrder - The order of the columns.
+ *
+ * @returns {React.ReactElement} A React element representing the drag and drop content context.
+ */
+declare const DragDropContentContext: React.FC<DragDropContentContextProps>;
+export default DragDropContentContext;

package/datatable/context/DragDropTableContext.d.ts

@@ -0,0 +1,35 @@
+import { default as React, Dispatch, SetStateAction } from 'react';
+import { ColumnOrderState } from '@tanstack/react-table';
+/**
+ * Props for the DragDropTableContext component.
+ *
+ * @category libs/datatable
+ * @subcategory Context
+ *
+ * @property {React.ReactNode} children - The child nodes to render within the context.
+ * @property {ColumnOrderState} columnOrder - The current order of columns in the table.
+ * @property {Dispatch<SetStateAction<ColumnOrderState>>} setColumnOrder - Function to update the column order.
+ */
+interface DragDropTableContextProps {
+    children: React.ReactNode;
+    columnOrder: ColumnOrderState;
+    setColumnOrder: Dispatch<SetStateAction<ColumnOrderState>>;
+}
+/**
+ * DragDropTableContext is a React component that provides a drag and drop context for reordering table columns.
+ * It utilizes the DndContext and Sortable functionalities from the '@dnd-kit' library to update the column order
+ * when a drag operation ends.
+ *
+ * @category libs/datatable
+ * @subcategory Context
+ *
+ * @component
+ * @param {DragDropTableContextProps} props - The properties for the DragDropTableContext component.
+ * @param {React.ReactNode} props.children - The child nodes to render within the context.
+ * @param {ColumnOrderState} props.columnOrder - The current order of columns in the table.
+ * @param {Dispatch<SetStateAction<ColumnOrderState>>} props.setColumnOrder - Function to update the column order.
+ *
+ * @returns {React.ReactElement} A React element representing the drag and drop table context.
+ */
+declare const DragDropTableContext: React.FC<DragDropTableContextProps>;
+export default DragDropTableContext;

package/datatable/context/index.d.ts

@@ -0,0 +1,167 @@
+import { default as React, MutableRefObject, PropsWithChildren } from 'react';
+import { IOptionalDataTableProps, ManualPaginationState, ReportDataState, TData } from '../common/types';
+import { ColumnDef, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingState, PaginationState, RowSelectionState, SortingState, Table, VisibilityState } from '@tanstack/react-table';
+import { UseScrollableTable } from '../hooks/useScrollableTable';
+/**
+ * Props for the DataTable component.
+ *
+ * @category libs/datatable
+ * @subcategory Props
+ *
+ * @template T - The type of data used in the table.
+ * @extends IOptionalDataTableProps<T> - Extends the optional properties for the data table.
+ *
+ * @property {string} tableId - Unique identifier for the table.
+ * @property {Array<T>} data - The data to be displayed in the table.
+ * @property {Array<ColumnDef<T, T>>} columns - The column definitions for the table.
+ * @property {boolean} [showHeader] - Whether to show the table header.
+ */
+export interface DataTableProps<T = TData> extends IOptionalDataTableProps<T> {
+    tableId: string;
+    data: Array<T>;
+    columns: Array<ColumnDef<T, T>>;
+    showHeader?: boolean;
+    mode?: 'dark' | 'light';
+}
+/**
+ * Interface for the table data.
+ *
+ * @category libs/datatable
+ * @subcategory Props
+ *
+ * @property {string} id - The id of the table.
+ * @property {PaginationState} pagination - The pagination state of the table.
+ * @property {SortingState} sorting - The sorting state of the table.
+ * @property {ColumnOrderState} columnOrder - The column order state of the table.
+ * @property {VisibilityState} columnVisibility - The column visibility state of the table.
+ * @property {ColumnPinningState} columnPinning - The column pinning state of the table.
+ * @property {ColumnFiltersState} columnFilters - The column filters state of the table.
+ * @property {ManualPaginationState} manualPagination - The manual pagination state of the table.
+ * @property {RowSelectionState} rowSelection - The row selection state of the table.
+ * @property {number} totalCount - The total count of the table.
+ */
+export interface ITableData {
+    id: string;
+    pagination: PaginationState;
+    sorting: SortingState;
+    columnOrder: ColumnOrderState;
+    columnVisibility: VisibilityState;
+    columnPinning: ColumnPinningState;
+    columnFilters: ColumnFiltersState;
+    manualPagination: ManualPaginationState;
+    rowSelection?: RowSelectionState;
+    totalCount?: number;
+    reportData: ReportDataState;
+}
+/**
+ * Interface for the initial table data.
+ *
+ * @category libs/datatable
+ * @subcategory Props
+ *
+ * @property {SortingState} initialSorting - The initial sorting state of the table.
+ * @property {ColumnOrderState} initialColumnOrder - The initial column order state of the table.
+ * @property {VisibilityState} initialColumnVisibility - The initial column visibility state of the table.
+ * @property {ColumnPinningState} initialColumnPinning - The initial column pinning state of the table.
+ * @property {ColumnFiltersState} initialColumnFilters - The initial column filters state of the table.
+ * @property {ManualPaginationState} initialManualPagination - The initial manual pagination state of the table.
+ * @property {PaginationState} initialPagination - The initial pagination state of the table.
+ * @property {RowSelectionState} initialRowSelection - The initial row selection state of the table.
+ * @property {number} initialTotalCount - The initial total count of the table.
+ */
+export interface ITableInitialData {
+    initialSorting: SortingState;
+    initialColumnOrder: ColumnOrderState;
+    initialColumnVisibility: VisibilityState;
+    initialColumnPinning: ColumnPinningState;
+    initialColumnFilters: ColumnFiltersState;
+    initialColumnSizing: ColumnSizingState;
+    initialManualPagination: ManualPaginationState;
+    initialPagination: PaginationState;
+    initialRowSelection?: RowSelectionState;
+    initialTotalCount?: number;
+    reportData: ReportDataState;
+}
+/**
+ * Interface for the data table store.
+ *
+ * @category libs/datatable
+ * @subcategory Props
+ *
+ * @property {ITableData} tableState - The table state of the table.
+ * @property {ITableInitialData} initialState - The initial state of the table.
+ * @property {Omit<DataTableProps, 'data'>} config - The config of the table.
+ * @property {UseScrollableTable} scrollProps - The scroll props of the table.
+ * @property {Table<TData>} table - The table of the table.
+ * @property {MutableRefObject<HTMLDivElement>} tableContainerRef - The table container ref of the table.
+ * @property {Utils} utils - The utils of the table.
+ */
+/**
+ * Interface for the utils of the table.
+ *
+ * @category libs/datatable
+ * @subcategory Props
+ *
+ * @property {boolean} isEmpty - Whether the table is empty.
+ * @property {boolean} checkState - Whether the table is in a check state.
+ * @property {boolean} handleFetch - Whether the table is fetching.
+ * @property {boolean} isSubComponent - Whether the table has a sub component.
+ * @property {boolean} isManualPagination - Whether the table has a manual pagination.
+ * @property {boolean} isRowSelection - Whether the table has a row selection.
+ */
+export interface DataTableStore {
+    tableState: ITableData;
+    initialState: ITableInitialData;
+    actions: {
+        setTotalCount?: (value: number) => void;
+        resetStoreData: () => void;
+        setColumnFilters: (value: ColumnFiltersState) => void;
+        onSetReportCellValue: (value: string, rowIndex: string, cellIndex: number, options?: {
+            hasSubTable?: boolean;
+        }) => void;
+        onSetReportHeader: (value: string, cellIndex: number) => void;
+        resetReportData: () => void;
+    };
+    config: Omit<DataTableProps, 'data'>;
+    scrollProps: UseScrollableTable;
+    table: Table<TData>;
+    tableContainerRef: MutableRefObject<HTMLDivElement>;
+    utils: {
+        isEmpty: boolean;
+        checkState: boolean;
+        handleFetch: boolean;
+        isSubComponent: boolean;
+        isManualPagination: boolean;
+        isRowSelection: boolean;
+    };
+    globalFilter: string;
+    setGlobalFilter: (value: string) => void;
+}
+/**
+ * Interface for the scroll props of the table.
+ *
+ * @category libs/datatable
+ * @subcategory Props
+ *
+ * @property {UseScrollableTable} scrollProps - The scroll props of the table.
+ */
+export type IScrollProps = UseScrollableTable;
+/**
+ * Context for the data table.
+ *
+ * @category libs/datatable
+ * @subcategory Context
+ *
+ * @property {DataTableStore} tableState - The table state of the table.
+ */
+export declare const DataTableContext: React.Context<DataTableStore | null>;
+export declare function DataTableProvider<TData>({ children, data, ...config }: PropsWithChildren<DataTableProps<TData>>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook for the data table context.
+ *
+ * @category libs/datatable
+ * @subcategory Hooks
+ *
+ * @returns {DataTableStore | null} The data table context.
+ */
+export declare function useDataTableContext(): DataTableStore | null;

package/datatable/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './useComponentEventListener';
+export * from './useDataTableStore';
+export * from './useGetCommonPinningStyles';
+export * from './useInitialState';
+export * from './useScrollableTable';
+export * from './useResetCacheVersion';