@fattureincloud/fic-design-system 0.6.5 → 0.7.0

package/dist/components/newTable/components/footer/Footer.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { HeaderGroup } from '@tanstack/react-table';
+interface FooterProps<T> {
+    footerGroup: HeaderGroup<T>[];
+}
+declare const Footer: <T>({ footerGroup }: FooterProps<T>) => JSX.Element;
+export default Footer;

package/dist/components/newTable/components/header/Header.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { HeaderGroup } from '@tanstack/react-table';
+import { OnSort, RowSize } from '../../types';
+interface HeaderProps<T> {
+    headerGroup: HeaderGroup<T>[];
+    headerSize?: RowSize;
+    onSort?: OnSort<T>;
+}
+declare const Header: <T>({ headerGroup, headerSize, onSort }: HeaderProps<T>) => JSX.Element;
+export default Header;

package/dist/components/newTable/components/header/headerCell/ActionHeaderCell.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Header } from '@tanstack/react-table';
+interface CustomHeaderCellProps<T> {
+    header: Header<T, unknown>;
+    onOpen?: (isOpen: boolean) => void;
+}
+declare const ActionHeaderCell: <T>({ header, onOpen }: CustomHeaderCellProps<T>) => JSX.Element;
+export default ActionHeaderCell;

package/dist/components/newTable/components/header/headerCell/HeaderCell.d.ts

@@ -0,0 +1,12 @@
+import { Header, SortDirection } from '@tanstack/react-table';
+import { default as React } from 'react';
+import { CustomSorted, OnSort, RowSize } from '../../../types';
+interface HeaderCellProps<T> {
+    header: Header<T, unknown>;
+    headerSize?: RowSize;
+    onSort?: OnSort<T>;
+    customSorted?: false | SortDirection;
+    setCustomSorted?: React.Dispatch<React.SetStateAction<CustomSorted<T> | undefined>>;
+}
+declare const HeaderCell: <T>({ header, headerSize, onSort, customSorted, setCustomSorted, }: HeaderCellProps<T>) => JSX.Element;
+export default HeaderCell;

package/dist/components/newTable/components/header/headerCell/styled.d.ts

@@ -0,0 +1,9 @@
+import { RowSize } from '../../../types';
+export declare const TextHeaderCell: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const Th: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, {
+    size?: RowSize | undefined;
+    minWidth?: number | undefined;
+    sortable: boolean;
+}, never>;
+export declare const TextHeaderCellWrapper: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const ActionCell: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/newTable/components/header/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useHeaderValues } from './useHeaderValues';
+export { default as useActionHeaderValues } from './useActionHeaderValues';

package/dist/components/newTable/components/header/hooks/useActionHeaderValues.d.ts

@@ -0,0 +1,16 @@
+import { Column, Header, Table } from '@tanstack/react-table';
+import { ActionType } from '../../../types';
+interface ActionHeaderValues<T> {
+    actionType: ActionType;
+    canSort: boolean;
+    isSorted: boolean;
+    isSortedDesc: string | null;
+    isSettingsEnabled: boolean;
+    toggleSortable: boolean;
+    favoriteSortable: boolean;
+    table: Table<T>;
+    headerTitle?: string | number;
+    allColumns: Column<T, unknown>[];
+}
+declare const useActionHeaderValues: <T>(header: Header<T, unknown>) => ActionHeaderValues<T>;
+export default useActionHeaderValues;

package/dist/components/newTable/components/header/hooks/useHeaderValues.d.ts

@@ -0,0 +1,14 @@
+import { Column, Header } from '@tanstack/react-table';
+import { TooltipProps } from '../../../../tooltip';
+import { ActionType } from '../../../types';
+interface HeaderValues<T> {
+    column: Column<T, unknown>;
+    actionType: ActionType;
+    canSort: boolean;
+    isSorted: boolean;
+    isSortedDesc: string | null;
+    minWidth?: number;
+    tooltip?: TooltipProps;
+}
+declare const useHeaderValues: <T>(header: Header<T, unknown>) => HeaderValues<T>;
+export default useHeaderValues;

package/dist/components/newTable/components/row/Row.d.ts

@@ -0,0 +1,10 @@
+import { Row } from '@tanstack/react-table';
+import React from 'react';
+import { RowSize } from '../../types';
+interface TrProps<T> extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement> {
+    row: Row<T>;
+    rowSize?: RowSize;
+    isLoading?: boolean;
+}
+declare const Tr: <T>({ row, isLoading }: TrProps<T>) => JSX.Element;
+export default Tr;

package/dist/components/newTable/components/row/styled.d.ts

@@ -0,0 +1,6 @@
+import { RowSize } from '../../types';
+export declare const TRow: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, {
+    mouseHover?: boolean | undefined;
+    size?: RowSize | undefined;
+    selected?: boolean | undefined;
+}, never>;

package/dist/components/newTable/components/utils.d.ts

@@ -0,0 +1,10 @@
+import { ColumnPinningPosition } from '@tanstack/react-table';
+import { DefaultTheme } from 'styled-components';
+interface Props {
+    theme: DefaultTheme;
+    isHeader: boolean;
+    isPopoverActive?: boolean;
+    isPinned: ColumnPinningPosition;
+}
+export declare const getFixedColumnsStyles: ({ theme, isHeader, isPopoverActive, isPinned }: Props) => React.CSSProperties;
+export {};

package/dist/components/newTable/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HEIGHT_SMALL = 42;
+export declare const HEIGHT_LARGE = 56;

package/dist/components/newTable/hooks/useColumnPinning.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ColumnPinningState } from '@tanstack/react-table';
+interface ReturnType {
+    readonly columnPinning: ColumnPinningState;
+    readonly setColumnPinning: React.Dispatch<React.SetStateAction<ColumnPinningState>>;
+}
+export declare const useColumnPinning: (defaultValues?: ColumnPinningState | undefined) => ReturnType;
+export {};

package/dist/components/newTable/hooks/usePagination.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { PaginationState } from '@tanstack/react-table';
+interface ReturnType {
+    readonly pageIndex: number;
+    readonly pageSize: number;
+    readonly setPagination: React.Dispatch<React.SetStateAction<PaginationState>>;
+}
+export declare const usePagination: (size: number) => ReturnType;
+export {};

package/dist/components/newTable/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NewTable } from './Table';
+export { ColumnDefType, ColumnsType, CellProps, BulkAction, RowActions, RowAction } from './types';

package/dist/components/newTable/providers/TableProvider/TableProvider.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TableContextProps, TableProviderProps } from '.';
+export declare const TableContext: React.Context<TableContextProps>;
+declare const TableProvider: ({ children, defaultRowSize }: TableProviderProps) => JSX.Element;
+export default TableProvider;

package/dist/components/newTable/providers/TableProvider/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TableProvider } from './TableProvider';
+export { TableContext } from './TableProvider';
+export { TableContextProps, TableProviderProps } from './types';

package/dist/components/newTable/providers/TableProvider/types.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { RowSize } from '../../types';
+export interface TableContextProps {
+    rowSize: RowSize;
+    setRowSize: (rowHeight: RowSize) => void;
+}
+export interface TableProviderProps {
+    children: React.ReactNode | React.ReactNode[];
+    defaultRowSize?: RowSize;
+}

package/dist/components/newTable/stories/actions.d.ts

@@ -0,0 +1,4 @@
+import { BulkAction, RowActions } from '../types';
+import { DataType } from './types';
+export declare const rowActions: RowActions<DataType>;
+export declare const bulkActions: BulkAction<DataType>[];

package/dist/components/newTable/stories/columns.d.ts

@@ -0,0 +1,3 @@
+import { ColumnsType } from '../types';
+import { DataType } from './types';
+export declare const columns: ColumnsType<DataType>[];

package/dist/components/newTable/stories/data.d.ts

@@ -0,0 +1,2 @@
+import { DataType } from './types';
+export declare const data: DataType[];

package/dist/components/newTable/stories/styled.d.ts

@@ -0,0 +1 @@
+export declare const TableWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/newTable/stories/types.d.ts

@@ -0,0 +1,9 @@
+import { CellProps } from '../types';
+export interface DataType {
+    id: string;
+    supplier: CellProps;
+    description: CellProps;
+    payment: CellProps;
+    amount: CellProps;
+    date: CellProps;
+}

package/dist/components/newTable/styled.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export declare const Container: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const ScrollableContent: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const TableWrapper: import("styled-components").StyledComponent<"table", import("styled-components").DefaultTheme, {}, never>;
+export declare const SortIndicator: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {
+    isSorted: boolean;
+    isSortedDesc: boolean;
+}, never>;
+export declare const PaginationContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/newTable/table.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, Story } from '@storybook/react';
+import { DataType } from './stories/types';
+import { TableProps } from './types';
+export declare const Template: Story<TableProps<DataType>>;
+declare const TableStories: Meta<TableProps<DataType>>;
+export default TableStories;

package/dist/components/newTable/types.d.ts

@@ -0,0 +1,171 @@
+/// <reference types="react" />
+import { DisplayColumnDef, GroupColumnDef, IdentifiedColumnDef, PaginationState, Row, SortDirection } from '@tanstack/react-table';
+import { AvatarProps } from '../avatar';
+import { ButtonProps } from '../buttons';
+import { DropdownItemType } from '../dropdown/types';
+import { IconProps } from '../icon';
+import { MicroTagProps } from '../microTag';
+import { TagProps } from '../tag';
+import { TooltipProps } from '../tooltip';
+export interface TableProps<T> {
+    uniqueId: keyof T;
+    data: T[];
+    columns: ColumnsType<T>[];
+    isSelectable?: boolean;
+    onRowSelectionChange?: (data: T[]) => void;
+    favorites?: string[];
+    onFavoritesChange?: (favourites: string[]) => void;
+    toggles?: string[];
+    onTogglesChange?: (toggles: string[]) => void;
+    rowSize?: RowSize;
+    headerSize?: RowSize;
+    sortable?: boolean;
+    sortDescFirst?: boolean;
+    onSort?: OnSort<T>;
+    isFavoritesSortable?: boolean;
+    isTogglesSortable?: boolean;
+    rowActions?: RowActions<T>;
+    bulkActions?: BulkAction<T>[];
+    isLoading?: boolean;
+    allSelectedCTA?: AllSelectedCTA;
+    noPagination?: boolean;
+    pageSize?: number;
+    listSize?: number;
+    enableSettings?: boolean;
+    settingsDropdownConfig?: SettingsDropdownConfig;
+    paginationPreviousText?: string;
+    paginationNextText?: string;
+    onPaginationChange?: (pagination: PaginationState) => void;
+    renderEmptyState?: () => JSX.Element;
+}
+interface SettingsDropdownConfig {
+    settingsTooltip?: TooltipProps;
+    displaySettingsLabel?: string;
+    visibleColumnsLabel?: string;
+    rowHeightLabel?: string;
+    unspecifiedRowsLabel?: string;
+    smallRowsLabel?: string;
+    largeRowsLabel?: string;
+}
+export declare enum RowSize {
+    UNSPECIFIED = 0,
+    SMALL,
+    LARGE
+}
+export declare enum ColumnDefType {
+    ACCESSOR = "accessor",
+    DISPLAY = "display",
+    GROUP = "group",
+    ACTION = "action"
+}
+interface ExtraColumnDef<T> extends IdentifiedColumnDef<T, CellProps> {
+    isEditable: boolean;
+    onChange: (text: string, row: Row<T>) => void;
+}
+interface InitalColumnDef<T> extends IdentifiedColumnDef<T, CellProps> {
+    isEditable?: false;
+    onChange?: never;
+}
+export declare type AccessorColumnDef<T> = InitalColumnDef<T> | ExtraColumnDef<T>;
+export declare enum ActionType {
+    CHECKBOX = "checkbox",
+    TOGGLE = "toggle",
+    FAVORITE = "favorite",
+    ROW_ACTIONS = "row_actions",
+    SETTINGS = "settings"
+}
+export declare type ActionColumnDef<T> = {
+    onActionChange?: (id: string) => void;
+    actionType: ActionType;
+    favorites?: string[];
+    toggles?: string[];
+    enableSorting?: boolean;
+    enableSettings?: boolean;
+    rowActions?: RowActions<T>;
+    settingsDropdownConfig?: SettingsDropdownConfig;
+} & IdentifiedColumnDef<T, CellProps>;
+export declare type AdditionalColumnDef = {
+    unitSymbol?: string;
+    minWidth?: number;
+    headerTooltip?: TooltipProps;
+};
+export declare type ColumnsType<T> = ({
+    columnDefType: ColumnDefType.ACCESSOR;
+    columnDef: AccessorColumnDef<T> & AdditionalColumnDef;
+} & BaseColumnsType<T>) | ({
+    columnDefType: ColumnDefType.DISPLAY;
+    columnDef: DisplayColumnDef<T, unknown> & AdditionalColumnDef;
+} & BaseColumnsType<T>) | ({
+    columnDefType: ColumnDefType.ACTION;
+    columnDef: ActionColumnDef<T> & AdditionalColumnDef;
+} & BaseColumnsType<T>) | ({
+    columnDefType: ColumnDefType.GROUP;
+    columnDef: GroupColumnDef<T, unknown>;
+} & BaseColumnsType<T>);
+interface BaseColumnsType<T> {
+    key: keyof T | Lowercase<keyof typeof ActionType>;
+}
+interface CustomCellWithAvatar extends BasicCustomCell {
+    avatar?: AvatarProps;
+    leadingIcon?: never;
+}
+interface CustomCellWithIcon extends BasicCustomCell {
+    avatar?: never;
+    leadingIcon?: IconProps;
+}
+export interface BasicCustomCell {
+    unitSymbol?: string;
+    trailingMicroTag?: MicroTagProps;
+    headline?: boolean;
+    content?: string | number;
+    tag?: TagProps;
+    isFavorite?: boolean;
+    isToggled?: boolean;
+}
+export declare type CustomCellProps = CustomCellWithIcon | CustomCellWithAvatar;
+export declare type CellProps = CustomCellProps | string | number;
+export interface RowActions<T> {
+    headerTitle?: string | number;
+    primary?: PrimaryAction<T>;
+    dropdown?: DropdownAction<T>;
+}
+export interface RowAction<T> {
+    text: string;
+    icon?: IconProps;
+    type?: DropdownItemType;
+    onClick: (row: Row<T>) => void;
+}
+declare type BasicPrimaryAction<T> = {
+    tooltip?: TooltipProps;
+    onClick: (row: Row<T>) => void;
+};
+interface PrimaryTextAction<T> extends BasicPrimaryAction<T> {
+    text?: string | number;
+    icon?: never;
+}
+interface PrimaryIconAction<T> extends BasicPrimaryAction<T> {
+    text?: never;
+    icon?: IconProps;
+}
+export declare type PrimaryAction<T> = PrimaryTextAction<T> | PrimaryIconAction<T>;
+export declare type DropdownAction<T> = {
+    items: RowAction<T>[];
+    tooltip?: TooltipProps;
+};
+export interface BulkAction<T> extends Omit<ButtonProps, 'onClick' | 'text'> {
+    onClick: (rows: T[]) => void;
+    text: string | JSX.Element;
+}
+export interface AllSelectedCTA {
+    description?: string;
+    onClick: () => void;
+    text: string;
+}
+export declare type OnSort<T> = (sortParams: {
+    sortBy: keyof T;
+    direction: false | SortDirection;
+}) => void;
+export declare type CustomSorted<T> = {
+    [key in keyof T]: false | SortDirection;
+};
+export {};

package/dist/components/newTable/utils.d.ts

@@ -0,0 +1,8 @@
+import { ColumnDef, SortDirection } from '@tanstack/react-table';
+import { CellProps } from './types';
+import { TableProps } from './types';
+interface ColumnsHelperProps<T> extends Omit<TableProps<T>, 'data' | 'uniqueId'> {
+}
+export declare const useColumnsHelper: <T>({ columns, isSelectable, favorites, isFavoritesSortable, onFavoritesChange, toggles, isTogglesSortable, onTogglesChange, rowActions, enableSettings, settingsDropdownConfig, }: ColumnsHelperProps<T>) => ColumnDef<T, CellProps>[];
+export declare const getNextSortingDirection: (direction?: false | SortDirection | undefined) => false | SortDirection;
+export {};

package/dist/components/oldTable/components/EmptyState.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface EmptyTablePageProps {
+    columnsCount: number;
+    EmptyPage?: JSX.Element;
+}
+declare const EmptyState: ({ columnsCount, EmptyPage }: EmptyTablePageProps) => JSX.Element;
+export default EmptyState;

package/dist/components/oldTable/components/SelectedRowsCount.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface Props {
+    count: number;
+    resetSelection: () => void;
+}
+declare const SelectedRowsCount: ({ count, resetSelection }: Props) => JSX.Element;
+export default SelectedRowsCount;

package/dist/components/oldTable/components/actions/ActionsCell.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from 'react-table';
+import { RowActions, TableData } from '../../types';
+interface Props<T extends TableData> {
+    row: Row<T>;
+    actions?: RowActions<T>;
+    renderActions?: () => JSX.Element;
+}
+declare const ActionsCell: <T extends TableData>({ row, actions, renderActions }: Props<T>) => JSX.Element;
+export default ActionsCell;

package/dist/components/oldTable/components/actions/DropdownActions.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from 'react-table';
+import { RowAction, TableData } from '../../types';
+interface Props<T extends TableData> {
+    row: Row<T>;
+    actions: RowAction<T>[];
+    rowIsDisabled?: boolean;
+}
+declare const DropdownActions: <T extends TableData>({ row, actions, rowIsDisabled }: Props<T>) => JSX.Element;
+export default DropdownActions;

package/dist/components/oldTable/components/actions/PrimaryAction.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Row } from 'react-table';
+import { DropdownItemType } from '../../../dropdown';
+import { RowAction, TableData } from '../../types';
+interface Props<T extends TableData> {
+    action: RowAction<T>;
+    row: Row<T>;
+    rowIsDisabled?: boolean;
+    type?: DropdownItemType;
+}
+declare const PrimaryAction: <T extends TableData>({ action, row, rowIsDisabled, type, }: Props<T>) => JSX.Element | null;
+export default PrimaryAction;

package/dist/components/oldTable/components/checkboxes/Cell.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { CellProps } from 'react-table';
+import { TableData } from '../../types';
+declare const Cell: <T extends TableData>({ row }: CellProps<T, any>) => JSX.Element;
+export default Cell;

package/dist/components/oldTable/components/checkboxes/Header.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { HeaderProps } from 'react-table';
+import { TableData } from '../../types';
+declare const Header: <T extends TableData>(props: HeaderProps<T>) => JSX.Element;
+export default Header;

package/dist/components/oldTable/components/checkboxes/useHeaderCheckboxProps.d.ts

@@ -0,0 +1,12 @@
+import { PropsWithChildren } from 'react';
+import { HeaderProps, TableToggleAllRowsSelectedProps } from 'react-table';
+import { TableData } from '../../types';
+interface Props<T extends TableData> {
+    headerProps: PropsWithChildren<HeaderProps<T>>;
+    selectSinglePage?: boolean;
+}
+interface ReturnType extends TableToggleAllRowsSelectedProps {
+    disabled: boolean;
+}
+declare const useHeaderCheckboxProps: <T extends TableData>({ headerProps, selectSinglePage, }: Props<T>) => ReturnType;
+export default useHeaderCheckboxProps;

package/dist/components/oldTable/components/loadingCell/LoadingCell.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ColumnInstance } from 'react-table';
+import { TableData } from '../../types';
+interface LoadingCellProps<T extends TableData> {
+    column: ColumnInstance<T>;
+}
+declare const LoadingCell: <T extends TableData>({ column }: LoadingCellProps<T>) => JSX.Element;
+export default LoadingCell;

package/dist/components/oldTable/components/pagination/PageButton.d.ts

@@ -0,0 +1,10 @@
+import { ReactText } from 'react';
+interface Props extends PageButtonWrapperProps {
+    text: ReactText;
+    onClick: () => void;
+}
+declare const PageButton: ({ text, onClick, isActive }: Props) => JSX.Element;
+export interface PageButtonWrapperProps {
+    isActive: boolean;
+}
+export default PageButton;

package/dist/components/oldTable/components/pagination/PaginationButtons.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { UsePaginationInstanceProps } from 'react-table';
+import { TableData } from '../../types';
+interface Props<T extends TableData> {
+    pageCount: number;
+    pageIndex: number;
+    gotoPage: UsePaginationInstanceProps<T>['gotoPage'];
+}
+declare const PaginationButtons: <T extends TableData>({ pageCount, pageIndex, gotoPage }: Props<T>) => JSX.Element;
+export default PaginationButtons;

package/dist/components/oldTable/components/pagination/utils.d.ts

@@ -0,0 +1,14 @@
+import { DefaultTheme } from 'styled-components';
+import { paletteColor } from '../../../../styles/types';
+import { PageButtonWrapperProps } from './PageButton';
+interface GetPageButtonParams extends PageButtonWrapperProps {
+    theme: DefaultTheme;
+}
+export interface PageButtonStyles {
+    color: paletteColor;
+    background: paletteColor;
+    hoverColor: paletteColor;
+    hoverBackground: paletteColor;
+}
+export declare const getPageButtonStyles: ({ theme, isActive }: GetPageButtonParams) => PageButtonStyles;
+export {};

package/dist/components/oldTable/components/tableBody/TableBody.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Row, UseTableInstanceProps } from 'react-table';
+import { TableData } from '../../types';
+interface Props<T extends TableData> {
+    rows: Row<T>[];
+    prepareRow: UseTableInstanceProps<T>['prepareRow'];
+    selectedRowsIds: string[];
+    isLoading: boolean;
+    onRowClick?: (row: Row<T>) => void;
+    rowHasFocus: boolean;
+    rowHeight: number | string;
+    selectableRows?: boolean;
+    setHighlightedRow: React.Dispatch<React.SetStateAction<number>>;
+    tableId: string;
+}
+declare const TableBody: <T extends TableData>({ isLoading, onRowClick, prepareRow, rowHasFocus, rowHeight, rows, selectableRows, selectedRowsIds, setHighlightedRow, tableId, }: Props<T>) => JSX.Element;
+export default TableBody;

package/dist/components/oldTable/components/tableBody/TableBodyTr.d.ts

@@ -0,0 +1,8 @@
+import { TableBodyTrStyles } from '../../utils';
+export interface TableBodyTrProps {
+    isSelected?: boolean;
+    isDisabled?: boolean;
+    rowHasFocus: boolean;
+}
+declare const TableBodyTr: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, import("../tableParts/styled").TrProps & TableBodyTrStyles & TableBodyTrProps, keyof TableBodyTrStyles>;
+export default TableBodyTr;

package/dist/components/oldTable/components/tableHeader/SortIndicator.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface Props {
+    isSorted: boolean;
+    isSortedDesc?: boolean;
+}
+declare const SortIndicator: ({ isSorted, isSortedDesc }: Props) => JSX.Element;
+export default SortIndicator;

package/dist/components/oldTable/components/tableHeader/TableHeader.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { HeaderGroup, SortingRule } from 'react-table';
+import { TableData } from '../../types';
+interface Props<T extends TableData> {
+    scrollBar: number;
+    headerGroups: HeaderGroup<T>[];
+    headerHeight?: number | string;
+    selectedRowsIds?: string[];
+    sortBy: SortingRule<T>[];
+}
+declare const TableHeader: <T extends TableData>({ headerHeight, headerGroups, scrollBar }: Props<T>) => JSX.Element;
+export default TableHeader;

package/dist/components/oldTable/components/tableParts/TableTd.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare type alignType = 'left' | 'center' | 'right';
+interface Props extends React.HTMLAttributes<HTMLTableDataCellElement> {
+    align?: alignType;
+    isLoading?: boolean;
+}
+export declare const TableTd: import("styled-components").StyledComponent<({ children, align, isLoading, ...rest }: Props) => JSX.Element, import("styled-components").DefaultTheme, Props, never>;
+export default TableTd;

package/dist/components/oldTable/components/tableParts/TableTh.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare type Props = React.HTMLAttributes<HTMLTableHeaderCellElement>;
+export declare const TableTh: import("styled-components").StyledComponent<({ children, ...rest }: Props) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export default TableTh;

package/dist/components/oldTable/components/tableParts/styled.d.ts

@@ -0,0 +1,17 @@
+export declare const TableWrapper: import("styled-components").StyledComponent<"table", import("styled-components").DefaultTheme, {}, never>;
+interface THeadProps {
+    scrollBar: number;
+}
+export declare const THead: import("styled-components").StyledComponent<"thead", import("styled-components").DefaultTheme, THeadProps, never>;
+interface TableBodyProps {
+    bodyHeight: number | string;
+}
+export declare const TBody: import("styled-components").StyledComponent<"tbody", import("styled-components").DefaultTheme, TableBodyProps, never>;
+export interface TrProps {
+    isHeader?: boolean;
+    rowHeight?: number | string;
+    headerHeight?: number | string;
+}
+export declare const TableTr: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, TrProps, never>;
+export declare const TFoot: import("styled-components").StyledComponent<"tfoot", import("styled-components").DefaultTheme, {}, never>;
+export {};

package/dist/components/oldTable/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_BODY_HEIGHT = 300;
+export declare const DEFAULT_ROW_HEIGHT = 40;

package/dist/components/oldTable/hooks/useCheckboxesComponents.d.ts

@@ -0,0 +1,4 @@
+import { Hooks } from 'react-table';
+import { TableData } from '../types';
+declare const useCheckboxesComponents: <T extends TableData>(hooks: Hooks<T>) => void;
+export default useCheckboxesComponents;