@fattureincloud/fic-design-system 0.6.0 → 0.6.2-temp-table

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { TableProps } from '../../types';
+interface BodyProps<T> extends Pick<TableProps<T>, 'rowSize'> {
+    rows: Row<T>[];
+    isLoading?: boolean;
+}
+declare const Body: <T>({ rows, rowSize, isLoading }: BodyProps<T>) => JSX.Element;
+export default Body;

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

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

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

@@ -0,0 +1,10 @@
+export declare const BulkBarWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    shown?: boolean | undefined;
+    allSelectedShown?: boolean | undefined;
+}, 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, {
+    shown?: boolean | undefined;
+}, never>;
+export declare const BulkActionsWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const SelectionCounter: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;

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

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

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Column, Row } from '@tanstack/react-table';
+import { ActionColumnDef, ActionType } from '../../../types';
+interface Props<T> extends ActionColumnDef<T> {
+    row: Row<T>;
+    actionType: ActionType;
+    isFavorite?: boolean;
+    isToggled?: boolean;
+    column: Column<T, unknown>;
+}
+declare const CustomActionCell: <T>({ actionType, row, isFavorite, isToggled, onActionChange, rowActions, column, }: Props<T>) => JSX.Element;
+export default CustomActionCell;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { RowAction } from '../../../types';
+interface Props<T> {
+    row: Row<T>;
+    dropdown: RowAction<T>[];
+    onOpen?: (isOpen: boolean) => void;
+}
+declare const DropdownActionCell: <T>({ dropdown, row, onOpen }: Props<T>) => JSX.Element;
+export default DropdownActionCell;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { PrimaryAction } from '../../../types';
+interface Props<T> {
+    row: Row<T>;
+    primary: PrimaryAction<T>;
+}
+declare const PrimaryActionCell: <T>({ primary, row }: Props<T>) => JSX.Element;
+export default PrimaryActionCell;

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

@@ -0,0 +1,3 @@
+export { default as CustomActionCell } from './CustomActionCell';
+export { default as PrimaryActionCell } from './PrimaryActionCell';
+export { default as DropdownActionCell } from './DropdownActionCell';

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

@@ -0,0 +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<({ className, color, fullWidth, href, iconLeft, iconRight, isDisabled, isLoading, onClick, size, target, text, type, }: import("../../../../buttons").ButtonProps) => JSX.Element, 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>;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { CellContext, Row } from '@tanstack/react-table';
+import { AccessorColumnDef, ActionColumnDef, AdditionalColumnDef, CustomCellProps, RowSize } from '../../../types';
+declare type Props<CellProps> = {
+    row: Row<CellProps>;
+    context: CellContext<CellProps, unknown>;
+    hover?: boolean;
+    rowSize?: RowSize;
+} & CustomCellProps & AccessorColumnDef<CellProps> & ActionColumnDef<CellProps> & AdditionalColumnDef;
+declare const CustomCell: <CellProps>({ content, isEditable, tag, unitSymbol, headline, leadingIcon, avatar, actionType, row, rowSize, onActionChange, isFavorite, isToggled, hover, onChange, trailingMicroTag, minWidth, rowActions, context, }: Props<CellProps>) => JSX.Element;
+export default CustomCell;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { AccessorColumnDef, AdditionalColumnDef, CustomCellProps } from '../../../types';
+declare type CustomInputProps<CellProps> = {
+    row: Row<CellProps>;
+    hover?: boolean;
+} & CustomCellProps & Omit<AccessorColumnDef<CellProps>, 'isEditable'> & AdditionalColumnDef;
+declare const CustomInput: <CellProps>({ hover, onChange, row, unitSymbol, content, }: CustomInputProps<CellProps>) => JSX.Element;
+export default CustomInput;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { AccessorColumnDef, CustomCellProps } from '../../../types';
+declare type TextAreaPopupProps<CellProps> = {
+    row: Row<CellProps>;
+    onBlur: () => void;
+} & CustomCellProps & Omit<AccessorColumnDef<CellProps>, 'isEditable'>;
+declare const TextAreaPopup: <CellProps>({ onChange, row, content, onBlur }: TextAreaPopupProps<CellProps>) => JSX.Element;
+export default TextAreaPopup;

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

@@ -0,0 +1 @@
+export declare const TEXTAREA_HEIGHT = 100;

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

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

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+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, {
+    confirm?: boolean | undefined;
+}, never>;

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

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

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

@@ -0,0 +1,16 @@
+import { Cell as TCell, Row } from '@tanstack/react-table';
+import { ActionType, CustomCellProps, RowActions } from '../../../types';
+interface CellValues<T> {
+    isFavorite: boolean;
+    isToggled: boolean;
+    isEditable: boolean;
+    content?: string | number;
+    unitSymbol?: string;
+    actionType: ActionType;
+    values: CustomCellProps;
+    onActionChange?: (id: string) => void;
+    minWidth?: number;
+    rowActions?: RowActions<T>;
+}
+declare const useCellValues: <T>(cell: TCell<T, unknown>, row: Row<T>) => CellValues<T>;
+export default useCellValues;

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface LoadingCellProps {
+    isActionCell?: boolean;
+    minWidth?: number;
+}
+declare const LoadingCell: ({ isActionCell, minWidth }: LoadingCellProps) => JSX.Element;
+export default LoadingCell;

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

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

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

@@ -0,0 +1,20 @@
+export declare const Td: import("styled-components").StyledComponent<"td", import("styled-components").DefaultTheme, {}, never>;
+export declare const Wrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const LeadingIconContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const AvatarContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Container: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    hasMeasureUnit?: boolean | undefined;
+}, never>;
+export declare const Content: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    hasMeasureUnit?: boolean | undefined;
+    headline?: boolean | undefined;
+    truncate?: boolean | undefined;
+}, never>;
+export declare const UnitContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    headline?: boolean | undefined;
+}, never>;
+export declare const MicroTagContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const InputTextWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    hasMeasureUnit?: boolean | undefined;
+}, never>;
+export declare const ContentContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

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 } 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,170 @@
+/// <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';
+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;
+}
+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/pagination/Pagination.d.ts

@@ -10,7 +10,6 @@ import { PaginationProps } from './types';
  * @param {number} currentPage Used to set the current page number
  * @param {string} prevText Define previous label text
  * @param {string} nextText Define next label text
- * @param {PaginationType} color Used to set the theme of the component
  */
 declare const Pagination: (props: PaginationProps) => JSX.Element;
 export default Pagination;

package/dist/components/pagination/pagination.stories.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="react" />
 import { Meta, Story } from '@storybook/react';
 import { PaginationProps } from './types';
 export declare const Template: Story<PaginationProps>;
-export declare const Normal: () => JSX.Element;
+export declare const Normal: Story<PaginationProps>;
 declare const PaginationStories: Meta<PaginationProps>;
 export default PaginationStories;

package/dist/components/pagination/paginationStyledWrapper.d.ts

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