@fattureincloud/fic-design-system 0.14.4 → 0.15.0

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

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 export declare const ActionCell: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const TextBtn: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../../../../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;
-export declare const IconBtn: import("styled-components").StyledComponent<({ className, color, icon, isDisabled, onClick, type }: import("../../../../buttons").IconButtonProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const IconBtn: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../../../../buttons").IconButtonProps & import("react").RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {}, never>;

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

@@ -2,6 +2,6 @@
 export declare const InputsWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const TextAreaWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const IconsWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const StyledIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../../../../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {
+export declare const StyledIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../../../../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {
     confirm?: boolean | undefined;
 }, never>;

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

@@ -2,5 +2,5 @@
 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<"div", 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, {}, never>;
+export declare const SortIndicator: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const PaginationContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/newTable_v2/Table.d.ts

@@ -0,0 +1,112 @@
+/// <reference types="react" />
+import { TableProps } from './types';
+/**
+ * @callback IsRowDisabledCallback
+ * @param {Row<TData>} row
+ * @returns {boolean}
+ *
+ * @typedef {Object} LoadingStyle
+ * @property {string} [backgroundColor]
+ * @property {string} [foregroundColor]
+ * @property {number|string} [height]
+ * @property {number|string} [width]
+ *
+ * @callback OnRowClickCallback
+ * @param {Row<TData>} row
+ * @returns {void}
+ *
+ * @callback RenderEmptyStateCallback
+ * @returns {JSX.Element}
+ *
+ * @callback RowTooltipCallback
+ * @param {Row<TData>} row
+ * @returns {string}
+ *
+ * @callback OnRowSelectionCallback
+ * @param {string[]} rowSelection
+ * @returns {void}
+ *
+ * @typedef {Object} AllSelectedCTA
+ * @property {string} [description]
+ * @property {function} onClick
+ * @property {string} text
+ *
+ * @callback OnPaginationChangeCallback
+ * @param {PaginationState} pagination
+ * @returns {void}
+ *
+ * @callback OnSortCallback
+ * @param {{ sortBy: keyof TData; direction: false | SortDirection }} sortParams
+ * @returns {void}
+ *
+ * @typedef {Object} SettingsLabels
+ * @property {string} [main]
+ * @property {string} [rowSizeLabel]
+ * @property {string} [rowSizeSmallLabel]
+ * @property {string} [rowSizeLargeLabel]
+ * @property {string} [columnsLabel]
+ *
+ * @callback OnSettingsChangeCallback
+ * @param {SettingsEvent} event
+ * @param {VariableSettings} settings
+ * @returns {void}
+ *
+ * @callback IsRowHighlightedCallback
+ * @param {Row<TData>} row
+ * @returns {boolean}
+ *
+ * @callback RowActionsCallback
+ * @param {Row<TData>} row
+ * @returns {RowActions<TData>}
+ *
+ * @callback RenderBulkActionsCallback
+ * @param {string[]} rows
+ * @returns {JSX.Element}
+ */
+/**
+ * @component
+ * Table component props list:
+ * @param {HTMLElement} [absoluteElementsPortal] - Used to render some components relative to this node, instead of using the table components
+ * @param {number} [actionColumnWidth] - The width of the action column, if present
+ * @param {number} [bodyHeight] - The height of the table body
+ * @param {ColumnsType<TData>[]} columns - The columns configuration
+ * @param {TData[]} data - The data to be displayed
+ * @param {RowSize} [headerSize] - Determines the height of the header
+ * @param {boolean} [isLoading] - If true, the table will display a loading state
+ * @param {IsRowDisabledCallback} [isRowDisabled] - A function that receives a row and returns a boolean to determine if the row is disabled
+ * @param {LoadingStyle} [loadingStyle] - The style of the rows and cells on loading state
+ * @param {OnRowClickCallback} [onRowClick] - A function that is called when the row is clicked
+ * @param {RenderEmptyStateCallback} [renderEmptyState] - A function that returns a JSX element to be displayed when the table is empty
+ * @param {RowTooltipCallback} [rowTooltip - A function that returns a string to be displayed as a tooltip over the row
+ * @param {boolean} [showFooter] - If true, the table will display a footer
+ * @param {keyof TData} uniqueId - The unique identifier of the data row
+ * @param {boolean} [isSelectable] - If true, the table will display a checkbox in the first column to allow row selection
+ * @param {string[]} [rowSelection] - The list of selected rows, obligatory if isSelectable is true
+ * @param {OnRowSelectionCallback} [onRowSelection] - A function that receives the updated row selection, obligatory if isSelectable is true
+ * @param {AllSelectedCTA} [allSelectedCTA] - The call to action to be displayed when multiple rows are selected
+ * @param {boolean} [noPagination] - If true, the table will not display a pagination component and data won't be paginated
+ * @param {number} [pageSize] - The number of rows per page, obligatory if noPagination is false
+ * @param {number} [listSize] - The total number of rows, obligatory if noPagination is false
+ * @param {string} [paginationPreviousText] - The text to be displayed in the previous page button
+ * @param {string} [paginationNextText] - The text to be displayed in the next page button
+ * @param {OnPaginationChangeCallback} [onPaginationChange] - A function that receives the updated pagination state, obligatory if noPagination is false
+ * @param {number} [totalPages] - The total number of pages, obligatory if noPagination is false
+ * @param {boolean} [resetPageIndex] - When this prop changes, the pageIndex will be reset to 1
+ * @param {boolean} [sortable] - If true, the table will be sortable
+ * @param {boolean} [sortDescFirst] - If true, the table will sort in descending order first
+ * @param {OnSortCallback} [onSort] - A function that receives the updated sort state, obligatory if sortable is true
+ * @param {boolean} [enableSettings] - If true, the table will display a settings button to allow column visibility and order customization
+ * @param {SettingsLabels} [settingsLabels] - The labels to be displayed in the settings popover
+ * @param {TooltipProps} [settingsTooltip] - The props passed to a tooltip component, shown when hovering the settings button
+ * @param {OnSettingsChangeCallback} [onSettingsChange] - A function that receives the updated settings state
+ * @param {string[]} [hideableColumns] - The columns ids that can be hidden, default is all columns
+ * @param {string[]} [sortableColumns] - The columns ids that can be sorted, default is all columns
+ * @param {IsRowHighlightedCallback} [isRowHighlighted] - A function that receives a row and returns a boolean to determine if the row is highlighted
+ * @param {string} [rowHighlightColor] - The color of the highlighted rows
+ * @param {string|JSX.Element} [actionsHeader] - The header of the action column
+ * @param {RowActions<TData>|RowActionsCallback} [rowActions] - The actions to be displayed in the action column
+ * @param {BulkAction[]} [bulkActions] - The actions to be displayed in the bulk bar, when selecting multiple rows
+ * @param {RenderBulkActionsCallback} [renderBulkActions] - A function that receives the selected rows and returns a JSX element
+ */
+declare const Table: <T>(props: TableProps<T>) => JSX.Element;
+export default Table;

package/dist/components/newTable_v2/components/body/Body.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row as RowType } from '@tanstack/react-table';
+import { TableProps } from '../../types';
+interface BodyProps<T> extends Pick<TableProps<T>, 'bodyHeight' | 'isLoading' | 'isRowDisabled' | 'isRowHighlighted' | 'onRowClick' | 'rowActions' | 'rowHighlightColor' | 'rowSelection' | 'rowTooltip'> {
+    pageIndex: number;
+    rows: RowType<T>[];
+}
+declare const Body: <T>({ bodyHeight, isLoading, isRowDisabled, isRowHighlighted, onRowClick, pageIndex, rowActions, rowHighlightColor, rowSelection, rowTooltip, rows, }: BodyProps<T>) => JSX.Element;
+export default Body;

package/dist/components/newTable_v2/components/body/styled.d.ts

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

package/dist/components/newTable_v2/components/bulkBar/BulkBar.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { AllSelectedCTA, BulkAction } from '../../types';
+interface BulkBarProps {
+    selectedRowData: string[];
+    bulkBarActions?: BulkAction[];
+    allSelectedCTA?: AllSelectedCTA;
+    renderBulkActions?: (rows: string[]) => JSX.Element;
+}
+declare const BulkBar: ({ allSelectedCTA, bulkBarActions, renderBulkActions, selectedRowData }: BulkBarProps) => JSX.Element;
+export default BulkBar;

package/dist/components/newTable_v2/components/bulkBar/styled.d.ts

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

package/dist/components/newTable_v2/components/cell/Cell.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Cell as RTCell, Row } from '@tanstack/react-table';
+interface Props<T> {
+    cell: RTCell<T, unknown>;
+    disableRow: boolean;
+    hover?: boolean;
+    isLoading?: boolean;
+    onClick?: () => void;
+    row: Row<T>;
+}
+declare const Cell: <T>({ cell, disableRow, hover, isLoading, onClick, row }: Props<T>) => JSX.Element;
+export default Cell;

package/dist/components/newTable_v2/components/cell/actionsCell/ActionsCell.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { TableProps } from '../../../types';
+declare type Props<T> = {
+    disableRow: boolean;
+    mouseHover: boolean;
+    isRowHighlighted?: boolean;
+    row: Row<T>;
+    rowActions?: TableProps<T>['rowActions'];
+    rowHighlightColor?: string;
+    selected: boolean;
+};
+declare const ActionsCell: <T>({ disableRow, isRowHighlighted, mouseHover, row, rowActions, rowHighlightColor, selected, }: Props<T>) => JSX.Element;
+export default ActionsCell;

package/dist/components/newTable_v2/components/cell/actionsCell/DropdownAction.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { DropdownActions } from '../../../types';
+declare type Props<T> = DropdownActions<T> & {
+    isDisabled: boolean;
+    row: Row<T>;
+};
+declare const DropdownAction: <T>({ isDisabled, items, row, tooltip }: Props<T>) => JSX.Element;
+export default DropdownAction;

package/dist/components/newTable_v2/components/cell/actionsCell/PrimaryActionButton.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { PrimaryAction } from '../../../types';
+declare type Props<T> = PrimaryAction<T> & {
+    isDisabled: boolean;
+    row: Row<T>;
+};
+declare const PrimaryActionButton: <T>({ className, color, icon, isDisabled, onClick, row, text, tooltip, }: Props<T>) => JSX.Element;
+export default PrimaryActionButton;

package/dist/components/newTable_v2/components/cell/actionsCell/styled.d.ts

@@ -0,0 +1,11 @@
+import { MappedProps } from '../../../utils';
+declare type ActionsTdProps = {
+    actionColumnWidth: number;
+    isDisabled: boolean;
+    isRowHighlighted?: boolean;
+    mouseHover: boolean;
+    rowHighlightColor?: string;
+    selected: boolean;
+};
+export declare const ActionsTd: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, MappedProps & ActionsTdProps, keyof MappedProps>;
+export {};

package/dist/components/newTable_v2/components/cell/checkboxCell/CheckboxCell.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+declare type Props<T> = {
+    disableRow: boolean;
+    mouseHover: boolean;
+    isRowHighlighted?: boolean;
+    row: Row<T>;
+    rowHighlightColor?: string;
+    rowSelection?: string[];
+    selected: boolean;
+};
+declare const CheckboxCell: <T>({ disableRow, isRowHighlighted, mouseHover, row, rowHighlightColor, rowSelection, selected, }: Props<T>) => JSX.Element;
+export default CheckboxCell;

package/dist/components/newTable_v2/components/cell/checkboxCell/styled.d.ts

@@ -0,0 +1,10 @@
+import { MappedProps } from '../../../utils';
+declare type CheckboxTdProps = {
+    isDisabled: boolean;
+    isRowHighlighted?: boolean;
+    mouseHover: boolean;
+    rowHighlightColor?: string;
+    selected: boolean;
+};
+export declare const CheckboxTd: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, MappedProps & CheckboxTdProps, keyof MappedProps>;
+export {};

package/dist/components/newTable_v2/components/cell/editableCell/CustomInput.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { EditableCellsColumn } from '../../../types';
+declare type CustomInputProps<T> = EditableCellsColumn<T> & {
+    disableRow: boolean;
+    hover?: boolean;
+    row: Row<T>;
+    content: string | number | null | undefined;
+};
+declare const CustomInput: <T>({ content, disableRow, hover, inputProps, onChange, row, }: CustomInputProps<T>) => JSX.Element;
+export default CustomInput;

package/dist/components/newTable_v2/components/cell/editableCell/styled.d.ts

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

package/dist/components/newTable_v2/components/cell/editableCell/textAreaPopup/TableTextArea.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TableTextAreaProps } from './types';
+declare const TableTextArea: <T>({ content, onChange, rect, row, setFocus }: TableTextAreaProps<T>) => JSX.Element;
+export default TableTextArea;

package/dist/components/newTable_v2/components/cell/editableCell/textAreaPopup/TextAreaPopup.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TextAreaPopupProps } from './types';
+declare const TextAreaPopup: <T>({ parentRect, ...rest }: TextAreaPopupProps<T>) => JSX.Element;
+export default TextAreaPopup;

package/dist/components/newTable_v2/components/cell/editableCell/textAreaPopup/styled.d.ts

@@ -0,0 +1,3 @@
+import { Coordinates, Dimensions } from '../../../../../../common/types';
+export declare const TextAreaWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, Coordinates & Partial<Dimensions>, never>;
+export declare const IconsWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/newTable_v2/components/cell/editableCell/textAreaPopup/types.d.ts

@@ -0,0 +1,16 @@
+import { Row } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+import { Coordinates, DSRect } from '../../../../../../common/types';
+import { EditableCellsColumn } from '../../../../types';
+declare type CommonProps<T> = EditableCellsColumn<T> & {
+    content: string | number | null | undefined;
+    row: Row<T>;
+    setFocus: Dispatch<SetStateAction<boolean>>;
+};
+export declare type TextAreaPopupProps<T> = CommonProps<T> & {
+    parentRect?: DOMRect;
+};
+export declare type TableTextAreaProps<T> = CommonProps<T> & {
+    rect: DSRect | Coordinates;
+};
+export {};

package/dist/components/newTable_v2/components/cell/hooks/useCellValues.d.ts

@@ -0,0 +1,11 @@
+import { Cell as RTCell } from '@tanstack/react-table';
+import { CellValue } from '../../../types';
+interface CellValues {
+    align: 'center' | 'left' | 'right';
+    content?: Exclude<CellValue, Record<string, unknown>>;
+    isEditable: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+}
+declare const useCellValues: <T>(cell: RTCell<T, unknown>) => CellValues;
+export default useCellValues;

package/dist/components/newTable_v2/components/cell/loadingCell/LoadingCell.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const LoadingCell: () => JSX.Element;
+export default LoadingCell;

package/dist/components/newTable_v2/components/cell/styled.d.ts

@@ -0,0 +1,9 @@
+declare type DSTdProps = {
+    justifyContent: 'center' | 'left' | 'right';
+    maxWidth?: number;
+    minWidth?: number;
+};
+export declare const BaseTd: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, {}, never>;
+export declare const DSTd: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, DSTdProps, never>;
+export declare const CutText: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export {};

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

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

package/dist/components/newTable_v2/components/footer/footerCell/FooterCell.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { Header } from '@tanstack/react-table';
+declare type Props<T> = {
+    header: Header<T, unknown>;
+};
+declare const FooterCell: <T>({ header }: Props<T>) => JSX.Element;
+export default FooterCell;

package/dist/components/newTable_v2/components/footer/footerCell/styled.d.ts

@@ -0,0 +1,10 @@
+import { ColumnPinningPosition } from '@tanstack/react-table';
+import { RowSize } from '../../../types';
+declare type DSThProps = {
+    footerSize?: RowSize;
+    isPinned: ColumnPinningPosition;
+    minWidth?: number;
+    maxWidth?: number;
+};
+export declare const DSThFooter: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, DSThProps, never>;
+export {};

package/dist/components/newTable_v2/components/footer/hooks/useFooterValues.d.ts

@@ -0,0 +1,8 @@
+import { ColumnPinningPosition, Header } from '@tanstack/react-table';
+interface FooterValues {
+    isPinned: ColumnPinningPosition;
+    maxWidth?: number;
+    minWidth?: number;
+}
+declare const useFooterValues: <T>(header: Header<T, unknown>) => FooterValues;
+export default useFooterValues;

package/dist/components/newTable_v2/components/footer/styled.d.ts

@@ -0,0 +1,7 @@
+import { RowSize } from '../../types';
+export declare const DSTFoot: import("styled-components").StyledComponent<"tfoot", import("styled-components").DefaultTheme, {}, never>;
+declare type DSTHeadProps = {
+    footerSize?: RowSize;
+};
+export declare const DSTrFooter: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, DSTHeadProps, never>;
+export {};

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { HeaderGroup, Table } from '@tanstack/react-table';
+import { TableProps } from '../../types';
+declare type HeaderProps<T> = Pick<TableProps<T>, 'headerSize' | 'onSort'> & {
+    actionsHeader?: string | JSX.Element;
+    headerGroups: HeaderGroup<T>[];
+    isSelectable?: boolean;
+    onRowSelection?: (e: string[]) => void;
+    rowSelection?: string[];
+    table: Table<T>;
+};
+declare const Header: <T>({ actionsHeader, headerGroups, headerSize, isSelectable, onRowSelection, onSort, rowSelection, table, }: HeaderProps<T>) => JSX.Element;
+export default Header;

package/dist/components/newTable_v2/components/header/actionsHeader/ActionsHeader.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type Props = {
+    actionsHeader?: string | JSX.Element;
+};
+declare const ActionsHeader: ({ actionsHeader }: Props) => JSX.Element;
+export default ActionsHeader;

package/dist/components/newTable_v2/components/header/actionsHeader/styled.d.ts

@@ -0,0 +1,6 @@
+declare type ActionsThHeaderProps = {
+    hasContent: boolean;
+    actionColumnWidth: number;
+};
+export declare const ActionsThHeader: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, ActionsThHeaderProps, never>;
+export {};

package/dist/components/newTable_v2/components/header/checkboxHeader/CheckboxHeader.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Table } from '@tanstack/react-table';
+declare type Props<T> = {
+    onRowSelection?: (e: string[]) => void;
+    rowSelection: string[];
+    table: Table<T>;
+};
+declare const CheckboxHeader: <T>({ onRowSelection, rowSelection, table }: Props<T>) => JSX.Element;
+export default CheckboxHeader;

package/dist/components/newTable_v2/components/header/checkboxHeader/styled.d.ts

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

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

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

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

@@ -0,0 +1,9 @@
+import { ColumnPinningPosition } from '@tanstack/react-table';
+declare type DSThProps = {
+    isPinned: ColumnPinningPosition;
+    minWidth?: number;
+    maxWidth?: number;
+    sortable: boolean;
+};
+export declare const DSThHeader: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, DSThProps, never>;
+export {};

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

@@ -0,0 +1,15 @@
+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;
+    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_v2/components/header/hooks/useHeaderValues.d.ts

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

package/dist/components/newTable_v2/components/header/styled.d.ts

@@ -0,0 +1,11 @@
+import { RowSize } from '../../types';
+declare type DSTHeadProps = {
+    scrollbarPadding: number;
+};
+export declare const DSTHead: import("styled-components").StyledComponent<"thead", import("styled-components").DefaultTheme, DSTHeadProps, never>;
+declare type DSTrHeaderProps = {
+    headerSize?: RowSize;
+};
+export declare const DSTrHeader: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, DSTrHeaderProps, never>;
+export declare const BaseThHeader: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, {}, never>;
+export {};

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Row as RowType } from '@tanstack/react-table';
+import { TableProps } from '../../types';
+declare type TrProps<T> = Pick<TableProps<T>, 'isLoading' | 'isRowDisabled' | 'isRowHighlighted' | 'onRowClick' | 'rowActions' | 'rowHighlightColor' | 'rowSelection' | 'rowTooltip'> & {
+    row: RowType<T>;
+};
+declare const Row: <T>({ isLoading, isRowDisabled, isRowHighlighted, onRowClick, row, rowActions, rowHighlightColor, rowSelection, rowTooltip, }: TrProps<T>) => JSX.Element;
+export default Row;

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

@@ -0,0 +1,14 @@
+import { RowSize } from '../../types';
+import { MappedProps } from '../../utils';
+declare type TRowProps = {
+    hasClick: boolean;
+    isDisabled: boolean;
+    isRowHighlighted?: boolean;
+    mouseHover: boolean;
+    rowHighlightColor?: string;
+    rowSize: RowSize;
+    selected: boolean;
+};
+export declare const DSTr: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, MappedProps & TRowProps, keyof MappedProps>;
+export declare const TooltipTd: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, {}, never>;
+export {};

package/dist/components/newTable_v2/components/settings/Settings.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { Table } from '@tanstack/react-table';
+declare type Props<T> = {
+    headerSize: number;
+    table: Table<T>;
+};
+declare const Settings: <T>({ headerSize, table }: Props<T>) => JSX.Element;
+export default Settings;

package/dist/components/newTable_v2/components/settings/settingsDropdownContent/DraggableColumn.d.ts

@@ -0,0 +1,11 @@
+import { Column } from '@tanstack/react-table';
+import React from 'react';
+declare type Props<T> = {
+    column: Column<T, unknown>;
+    dragging: boolean;
+    onDragEnd: React.HTMLProps<HTMLDivElement>['onDragEnd'];
+    onDragOver: React.HTMLProps<HTMLDivElement>['onDragOver'];
+    onDragStart: (event: React.DragEvent<HTMLDivElement>, parent: HTMLDivElement) => void;
+};
+declare const DraggableColumn: <T>({ column, dragging, onDragEnd, onDragOver, onDragStart }: Props<T>) => JSX.Element;
+export default DraggableColumn;

package/dist/components/newTable_v2/components/settings/settingsDropdownContent/SettingsDropdownContent.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { Table } from '@tanstack/react-table';
+declare type Props<T> = {
+    table: Table<T>;
+};
+declare const SettingsDropdownContent: <T>({ table }: Props<T>) => JSX.Element;
+export default SettingsDropdownContent;

package/dist/components/newTable_v2/components/settings/settingsDropdownContent/styled.d.ts

@@ -0,0 +1,9 @@
+export declare const ContentWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Details: import("styled-components").StyledComponent<"details", import("styled-components").DefaultTheme, {}, never>;
+export declare const RadioWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const DraggableContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const DraggableOption: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const DragIcon: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    dragging: boolean;
+    draggable: boolean;
+}, never>;

package/dist/components/newTable_v2/components/settings/styled.d.ts

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

package/dist/components/newTable_v2/components/toggle/Toggle.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+interface ToggleProps {
+    checked?: boolean;
+    disabled?: boolean;
+    onChange?: (checked: boolean) => void;
+}
+/**
+ * Component Props:
+ * @param {boolean} checked Used to set toggle status
+ * @param {boolean} disabled Disable the toggle
+ * @param {function} onChange Callback on toggle click
+ */
+declare const Toggle: ({ checked, disabled, onChange }: ToggleProps) => JSX.Element;
+export default Toggle;

package/dist/components/newTable_v2/components/toggle/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SLIDER_HEIGHT = 12;
+export declare const SLIDER_WIDTH = 12;
+export declare const SLIDER_MARGIN = 2;

package/dist/components/newTable_v2/components/toggle/index.d.ts

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

package/dist/components/newTable_v2/components/toggle/styled.d.ts

@@ -0,0 +1,5 @@
+export declare const Wrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Slider: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {
+    disabled: boolean;
+}, never>;
+export declare const Input: import("styled-components").StyledComponent<"input", import("styled-components").DefaultTheme, {}, never>;