@fattureincloud/fic-design-system 0.15.11-alpha.2 → 0.17.1

package/dist/components/form/datepicker/components/DatePickerHeader.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
 import { ReactDatePickerCustomHeaderProps } from 'react-datepicker';
 export interface DatePickerHeaderProps extends ReactDatePickerCustomHeaderProps {
-    yearsDisplayed: number;
-    setHideMonth: (value: boolean) => void;
     hideYearSelection: boolean;
+    setHideMonth: (value: boolean) => void;
+    yearsRange?: number;
 }
 declare const DatePickerHeader: (props: DatePickerHeaderProps) => JSX.Element;
 export default DatePickerHeader;

package/dist/components/form/datepicker/components/hooks/useDatePickerHeaderShowLogic.d.ts

@@ -11,5 +11,5 @@ interface ReturnType {
     showBottomArrow: boolean;
     showLRArrows: boolean;
 }
-declare const useDatePickerHeaderShowLogic: ({ date, decreaseMonth, increaseMonth, prevMonthButtonDisabled, nextMonthButtonDisabled, nextYearButtonDisabled, prevYearButtonDisabled, decreaseYear, increaseYear, }: DatePickerHeaderProps) => ReturnType;
+declare const useDatePickerHeaderShowLogic: ({ date, decreaseMonth, decreaseYear, increaseMonth, increaseYear, nextMonthButtonDisabled, nextYearButtonDisabled, prevMonthButtonDisabled, prevYearButtonDisabled, }: DatePickerHeaderProps) => ReturnType;
 export default useDatePickerHeaderShowLogic;

package/dist/components/form/datepicker/components/yearPicker/YearPicker.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { ReactDatePickerCustomHeaderProps } from 'react-datepicker';
+interface Props extends Pick<ReactDatePickerCustomHeaderProps, 'date' | 'changeYear'> {
+    yearsRange?: number;
+}
+declare const YearPicker: ({ changeYear, date, yearsRange }: Props) => JSX.Element;
+export default YearPicker;

package/dist/components/form/datepicker/components/yearPicker/styled.d.ts

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

package/dist/components/form/datepicker/datePickerPalette.d.ts

@@ -30,7 +30,6 @@ export interface DatePickerPalette {
     weekDaysNames: DaysNamesPalette;
     days: DayPalette;
     item: ItemPalette;
-    defaultYearsDisplayed: number;
 }
 declare const datePickerPalette: DatePickerPalette;
 export default datePickerPalette;

package/dist/components/form/datepicker/datepicker.stories.d.ts

@@ -10,6 +10,11 @@ export declare const WithCustomButton: Story<DatePickerProps & {
     containerWidth: number;
     containerHeight: number;
 }>;
+export declare const Range: Story<DatePickerProps & {
+    renderWrapper: boolean;
+    containerWidth: number;
+    containerHeight: number;
+}>;
 declare const DatePickerStories: Meta<DatePickerProps & {
     renderWrapper: boolean;
     containerWidth: number;

package/dist/components/form/datepicker/types.d.ts

@@ -12,12 +12,11 @@ export interface RenderCustomFooterProps extends DatePickerImplProps {
     isOpen: boolean;
     setIsOpen: Dispatch<SetStateAction<boolean>>;
 }
-export interface DatePickerImplProps extends Omit<ReactDatePickerProps, 'onChange'>, CommonFormTypes {
+export interface DatePickerImplProps extends Omit<ReactDatePickerProps<never, true>, 'onChange'>, CommonFormTypes {
     date?: Date | null;
     startDate?: Date | null;
     endDate?: Date | null;
     setDate: Dispatch<SetStateAction<Date | null>>;
-    yearsDisplayed?: number;
     hasTodayButton?: boolean;
     customButtons?: CustomButtonProps[];
     renderCustomFooter?: RenderCustomFooterType;
@@ -28,5 +27,8 @@ export interface DatePickerImplProps extends Omit<ReactDatePickerProps, 'onChang
     includeDates?: Date[];
     excludeDates?: Date[];
     hideYearSelection?: boolean;
+    yearsRange?: number;
+    dateRange?: [Date | null, Date | null];
+    setDateRange?: Dispatch<SetStateAction<[Date | null, Date | null]>>;
 }
 export declare type DatePickerProps = LabelProps & DatePickerImplProps;

package/dist/components/form/inputText/InputText.d.ts

@@ -10,6 +10,7 @@ declare const _default: React.ForwardRefExoticComponent<import("../label").Label
     onKeyDown?: React.KeyboardEventHandler<HTMLInputElement> | undefined;
     onKeyPress?: React.KeyboardEventHandler<HTMLInputElement> | undefined;
     onKeyUp?: React.KeyboardEventHandler<HTMLInputElement> | undefined;
+    readOnly?: boolean | undefined;
     required?: boolean | undefined;
 } & {
     actionIcon?: import("../../icon").IconProps | undefined;

package/dist/components/form/inputText/components/InputElement.d.ts

@@ -15,6 +15,7 @@ declare const _default: React.ForwardRefExoticComponent<import("../../common/typ
     onKeyDown?: React.KeyboardEventHandler<HTMLInputElement> | undefined;
     onKeyPress?: React.KeyboardEventHandler<HTMLInputElement> | undefined;
     onKeyUp?: React.KeyboardEventHandler<HTMLInputElement> | undefined;
+    readOnly?: boolean | undefined;
     required?: boolean | undefined;
 } & {
     actionIcon?: import("../../../icon").IconProps | undefined;

package/dist/components/form/inputText/types.d.ts

@@ -6,7 +6,7 @@ import { LabelProps } from '../label';
 import { UnitDropdownProps } from './components/UnitDropdown';
 export declare const inputTypesArray: readonly ["password", "text", "number", "code", "telephone"];
 export declare type inputTypes = (typeof inputTypesArray)[number];
-declare type HTMLInputProps = Pick<InputHTMLAttributes<HTMLInputElement>, 'autoFocus' | 'className' | 'name' | 'onBlur' | 'onChange' | 'onFocus' | 'onKeyDown' | 'onKeyPress' | 'onKeyUp' | 'required' | 'style'>;
+declare type HTMLInputProps = Pick<InputHTMLAttributes<HTMLInputElement>, 'autoFocus' | 'className' | 'name' | 'onBlur' | 'onChange' | 'onFocus' | 'onKeyDown' | 'onKeyPress' | 'onKeyUp' | 'required' | 'style' | 'readOnly'>;
 export declare type InputElementProps = CommonFormTypes & HTMLInputProps & {
     actionIcon?: IconProps;
     autoComplete?: string;

package/dist/components/tableV3/TableV3.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 TableV3: <T>(props: TableProps<T>) => JSX.Element;
+export default TableV3;

package/dist/components/tableV3/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>, 'isLoading' | 'isRowDisabled' | 'isRowHighlighted' | 'onRowClick' | 'rowActions' | 'rowHighlightColor' | 'rowSelection' | 'rowTooltip'> {
+    pageIndex: number;
+    rows: RowType<T>[];
+}
+declare const Body: <T>({ isLoading, isRowDisabled, isRowHighlighted, onRowClick, pageIndex, rowActions, rowHighlightColor, rowSelection, rowTooltip, rows, }: BodyProps<T>) => JSX.Element;
+export default Body;

package/dist/components/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/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/tableV3/components/cell/hooks/useCellValues.d.ts

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

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

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

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

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+declare type DSTdProps = {
+    fixedWidth?: number;
+    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, Partial<Pick<import("react").DetailedHTMLProps<import("react").TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "key" | keyof import("react").TdHTMLAttributes<HTMLTableDataCellElement>> & {
+    ref?: ((instance: HTMLTableDataCellElement | null) => void) | import("react").RefObject<HTMLTableDataCellElement> | null | undefined;
+} & {
+    minWidth?: number | undefined;
+    maxWidth?: number | undefined;
+    fixedWidth?: number | undefined;
+}> & {
+    [others: string]: any;
+} & DSTdProps, string | number>;
+export declare const CutText: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export {};

package/dist/components/tableV3/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/tableV3/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/tableV3/components/footer/footerCell/styled.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+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, Partial<Pick<import("react").DetailedHTMLProps<import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "key" | keyof import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>> & {
+    ref?: ((instance: HTMLTableHeaderCellElement | null) => void) | import("react").RefObject<HTMLTableHeaderCellElement> | null | undefined;
+} & {
+    minWidth?: number | undefined;
+    maxWidth?: number | undefined;
+    fixedWidth?: number | undefined;
+}> & {
+    [others: string]: any;
+} & DSThProps, string | number>;
+export {};

package/dist/components/tableV3/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/tableV3/components/footer/styled.d.ts

@@ -0,0 +1,12 @@
+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 declare const CheckboxFooter: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, {}, never>;
+declare type ActionsFooterProps = {
+    actionColumnWidth: number;
+};
+export declare const ActionsFooter: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, ActionsFooterProps, never>;
+export {};

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

@@ -0,0 +1,12 @@
+/// <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>[];
+    onRowSelection?: (e: string[]) => void;
+    rowSelection?: string[];
+    table: Table<T>;
+};
+declare const Header: <T>({ actionsHeader, headerGroups, headerSize, onRowSelection, onSort, rowSelection, table, }: HeaderProps<T>) => JSX.Element;
+export default Header;

package/dist/components/tableV3/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/tableV3/components/header/actionsHeader/styled.d.ts

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

package/dist/components/tableV3/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/tableV3/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/tableV3/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/tableV3/components/header/headerCell/styled.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { ColumnPinningPosition } from '@tanstack/react-table';
+declare type DSThProps = {
+    fixedWidth?: number;
+    isPinned: ColumnPinningPosition;
+    minWidth?: number;
+    maxWidth?: number;
+    sortable: boolean;
+};
+export declare const DSThHeader: import("styled-components").StyledComponent<"th", import("styled-components").DefaultTheme, Partial<Pick<import("react").DetailedHTMLProps<import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "key" | keyof import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>> & {
+    ref?: ((instance: HTMLTableHeaderCellElement | null) => void) | import("react").RefObject<HTMLTableHeaderCellElement> | null | undefined;
+} & {
+    minWidth?: number | undefined;
+    maxWidth?: number | undefined;
+    fixedWidth?: number | undefined;
+}> & {
+    [others: string]: any;
+} & DSThProps, string | number>;
+export {};

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

@@ -0,0 +1,14 @@
+import { Column, Header } from '@tanstack/react-table';
+import { TooltipProps } from '../../../../tooltip';
+interface HeaderValues<T> {
+    canSort: boolean;
+    column: Column<T, unknown>;
+    fixedWidth?: number;
+    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/tableV3/components/header/styled.d.ts

@@ -0,0 +1,8 @@
+import { RowSize } from '../../types';
+export declare const DSTHead: import("styled-components").StyledComponent<"thead", import("styled-components").DefaultTheme, {}, 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/tableV3/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;