@fattureincloud/fic-design-system 0.13.3 → 0.14.1

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

@@ -0,0 +1,4 @@
+export declare const FlexRow: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    gap?: number | undefined;
+}, never>;
+export declare const FlexColumn: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/common/hooks/useOutsideClick.d.ts

@@ -1,3 +1,3 @@
 import React from 'react';
-declare const useOutsideClick: (ref: React.MutableRefObject<HTMLDivElement | null>, showComponent?: boolean | undefined, closeAction?: (() => void) | undefined) => void;
+declare const useOutsideClick: (ref: React.MutableRefObject<HTMLDivElement | null>, showComponent: boolean, closeAction: () => void, additionalRefs?: React.MutableRefObject<HTMLElement | null>[] | undefined) => void;
 export default useOutsideClick;

package/dist/common/types/misc.d.ts

@@ -5,3 +5,4 @@ export declare enum ComponentType {
     SUCCESS = "success",
     WARNING = "warning"
 }
+export declare type Nullish<T> = T | null | undefined;

package/dist/common/utils/dsUtils.d.ts

@@ -1,3 +1,4 @@
+import { Nullish } from '../types';
 export declare const HEX_REGEX: RegExp;
 export declare const isHexColor: (value: string) => boolean;
 export declare const isNumber: (n: number | string | undefined) => boolean;
@@ -6,12 +7,14 @@ export declare const pixelToNumber: (s: string) => number;
 export declare const generateRandomId: () => string;
 export declare const stringToFloat: (n: string) => number;
 export declare const isNumeric: (n: string) => boolean;
+export declare const isset: <T>(value: Nullish<T>) => value is T;
 /**
  * Convert a number into italian currency value with euro symbol
  * @param {number} number
  * @returns {string} string
  */
 export declare const currency: (number: number | string) => string;
-export declare const isPaletteColor: (color: string) => color is "black" | "white" | "grey" | "blue" | "indigo" | "yellow" | "orange" | "red" | "green" | "fuchsia" | "pink" | "cyan" | "primary";
+export declare const isPaletteColor: (color: string | null | undefined) => color is "black" | "white" | "grey" | "blue" | "indigo" | "yellow" | "orange" | "red" | "green" | "fuchsia" | "pink" | "cyan" | "primary";
 export declare const isBWColor: (color: string) => color is "black" | "white";
 export declare const isColor: (color: string) => color is "grey" | "blue" | "indigo" | "yellow" | "orange" | "red" | "green" | "fuchsia" | "pink" | "cyan" | "primary";
+export declare const isBoolean: (value: unknown) => value is boolean;

package/dist/components/accordion/accordion.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { AccordionProps } from './types';
+/**
+ * @param open pass without setOpen to open by default
+ * @param setOpen pass only to control accordion opening/closing externally
+ * @param renderLateralActions
+ * @param renderTitle
+ * @param renderBody
+ * @param title
+ * @param lateralActions
+ * @constructor
+ */
+declare const Accordion: ({ open, setOpen, renderLateralActions, renderTitle, renderBody, title, lateralActions, }: AccordionProps) => JSX.Element;
+export default Accordion;

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

@@ -0,0 +1,6 @@
+import { Meta, Story } from '@storybook/react';
+import { ComponentProps } from 'react';
+import { Accordion, AccordionProps } from '.';
+export declare const Template: Story<AccordionProps>;
+declare const AccordionStories: Meta<ComponentProps<typeof Accordion>>;
+export default AccordionStories;

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

@@ -0,0 +1,2 @@
+export { default as Accordion } from './accordion';
+export { AccordionProps } from './types';

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

@@ -0,0 +1,5 @@
+export declare const TitleContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Title: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const ActionIcon: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const HeaderElement: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Body: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

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

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+export declare type AccordionProps = CommonAccordionProps & (OptionalAccordionProps | OptionalAccordionPropsRef);
+interface CommonAccordionProps {
+    title?: string;
+    renderTitle?: () => JSX.Element;
+    renderBody: () => JSX.Element;
+    renderLateralActions?: JSX.Element;
+    lateralActions?: Array<{
+        icon: JSX.Element;
+        action: () => void;
+    }>;
+}
+interface OptionalAccordionProps {
+    open: boolean;
+    setOpen: (e: boolean) => void;
+}
+interface OptionalAccordionPropsRef {
+    open?: boolean;
+    setOpen?: never;
+}
+export {};

package/dist/components/buttons/button/Button.d.ts

@@ -1,11 +1,11 @@
-import { ReactText } from 'react';
+import React, { ReactText } from 'react';
 import { IconProps } from '../../icon';
 import { WrapperProps } from './types';
-export interface ButtonProps extends Partial<WrapperProps> {
+export interface ButtonProps extends Omit<Partial<WrapperProps>, 'ref'> {
     text?: ReactText | JSX.Element;
     iconLeft?: IconProps;
     iconRight?: IconProps;
     isLoading?: boolean;
 }
-declare const Button: ({ className, color, fullWidth, href, iconLeft, iconRight, isDisabled, isLoading, onClick, size, target, text, type, }: ButtonProps) => JSX.Element;
-export default Button;
+declare const _default: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLDivElement | HTMLAnchorElement>>;
+export default _default;

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

@@ -20,6 +20,7 @@ export declare enum CardElevation {
 export declare type StyledCardProps = {
     color?: CardColor;
     elevation?: CardElevation;
+    outlined?: boolean;
     type?: CardType;
 };
 export declare type CardProps = HTMLAttributes<HTMLDivElement> & StyledCardProps & {

package/dist/components/carousel/components/carouselMainMedia/styled.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="react" />
 export declare const Image: import("styled-components").StyledComponent<({ src, className, showVideoControls }: import("../common/media/Media").MediaProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const FullScreenButton: import("styled-components").StyledComponent<({ className, color, icon, isDisabled, onClick, type }: import("../../../buttons").IconButtonProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
-export declare const Wrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Wrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    gap?: number | undefined;
+}, never>;

package/dist/components/carousel/components/carouselThumbnails/styled.d.ts

@@ -1,5 +1,7 @@
 /// <reference types="react" />
-export declare const Wrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Wrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    gap?: number | undefined;
+}, never>;
 export declare const CarouselThumbnailsWrapper: import("styled-components").StyledComponent<"ul", import("styled-components").DefaultTheme, {
     mediaCount: number;
 }, never>;

package/dist/components/drawer/drawer.d.ts

@@ -1,10 +1,10 @@
 import React, { ReactNode } from 'react';
 export interface DrawerProps {
-    show?: boolean;
+    show: boolean;
     title?: string;
     renderHeader?: () => JSX.Element;
     renderFooter?: () => JSX.Element;
-    actionClose?: () => void;
+    actionClose: () => void;
     allowOutsideClickClose?: boolean;
     children?: ReactNode;
     fullscreen?: boolean;

package/dist/components/dropdown/DropdownImpl.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 import { DropdownProps } from './types';
-declare const DropdownImpl: ({ className, content, fullWidth, maxWidth, maxHeight, minWidthAsTrigger, placement, renderContent, renderTrigger, triggerStyles, title, forceOpen, disableArrowNavigation, isDisabled, emptyState, onOpen, withPadding, offsetY, forceClose, onClose, sideButton, }: DropdownProps) => JSX.Element;
+declare const DropdownImpl: ({ className, content, disableArrowNavigation, emptyState, fullWidth, isDisabled, maxHeight, maxWidth, minWidthAsTrigger, offsetY, onClose, onOpen, open, outsideTriggers, placement, renderContent, renderTrigger, setOpen, sideButton, title, triggerStyles, withPadding, }: DropdownProps) => JSX.Element;
 export default DropdownImpl;

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

@@ -2,6 +2,7 @@
 import { Meta } from '@storybook/react';
 import { DropdownProps } from './types';
 export declare const Simple: () => JSX.Element;
+export declare const WithExternalTrigger: () => JSX.Element;
 export declare const WithKnobs: () => JSX.Element;
 export declare const WithButton: () => JSX.Element;
 declare const DropdownStories: Meta<DropdownProps>;

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

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 export declare const WithButtonWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const LeftButton: 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 RightButton: 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 LeftButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;
+export declare const RightButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;

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

@@ -1,5 +1,5 @@
 import { Placement } from '@popperjs/core/lib/enums';
-import React, { CSSProperties, MouseEventHandler, ReactNode } from 'react';
+import React, { CSSProperties, Dispatch, MouseEventHandler, ReactNode, SetStateAction } from 'react';
 import { ButtonProps } from '../buttons';
 import { IconProps } from '../icon';
 export declare type TitleProps = {
@@ -7,76 +7,86 @@ export declare type TitleProps = {
 };
 export declare type closeDropdownType = () => void;
 export declare type renderContentType = (closeDropdown: closeDropdownType) => React.ReactNode;
-export declare type DropdownProps = {
+declare type BaseProps = {
     className?: string;
-    title?: string;
-    renderTrigger?: () => React.ReactNode;
-    triggerStyles?: CSSProperties;
     content?: DropdownItemProps[];
-    renderContent?: renderContentType;
-    maxWidth?: string | number;
-    maxHeight?: string | number;
-    fullWidth?: boolean;
-    placement?: Placement;
-    minWidthAsTrigger?: boolean;
-    forceOpen?: boolean;
     disableArrowNavigation?: boolean;
-    isDisabled?: boolean;
     emptyState?: JSX.Element;
-    onOpen?: (isOpen: boolean) => void;
-    onClose?: (isOpen: boolean) => void;
-    withPadding?: boolean;
+    fullWidth?: boolean;
+    isDisabled?: boolean;
+    maxHeight?: string | number;
+    maxWidth?: string | number;
+    minWidthAsTrigger?: boolean;
     offsetY?: number;
-    forceClose?: boolean;
+    onClose?: (isOpen: boolean) => void;
+    onOpen?: (isOpen: boolean) => void;
+    placement?: Placement;
+    renderContent?: renderContentType;
+    renderTrigger?: () => React.ReactNode;
     sideButton?: Pick<ButtonProps, 'text' | 'iconLeft' | 'iconRight' | 'onClick'>;
+    title?: string;
+    triggerStyles?: CSSProperties;
+    withPadding?: boolean;
+};
+declare type ControlledStateProps = BaseProps & {
+    open: boolean;
+    setOpen: Dispatch<SetStateAction<boolean>>;
+    outsideTriggers?: React.MutableRefObject<HTMLElement | null>[];
 };
+declare type UncontrolledStateProps = BaseProps & {
+    open?: never;
+    setOpen?: never;
+    outsideTriggers?: never;
+};
+export declare type DropdownProps = ControlledStateProps | UncontrolledStateProps;
 export declare type DropdownItemType = 'default' | 'danger' | 'success' | 'warning' | 'link';
 export interface DropdownItemProps {
-    text: string | JSX.Element;
-    className?: string;
-    icon?: IconProps;
     active?: boolean;
-    shortcut?: string;
-    onClick?: MouseEventHandler;
-    maxWidth?: DropdownProps['maxWidth'];
-    fullWidth?: DropdownProps['fullWidth'];
     children?: ReactNode;
+    className?: string;
+    fullWidth?: DropdownProps['fullWidth'];
+    icon?: IconProps;
     isDisabled?: boolean;
-    type?: DropdownItemType;
-    onMouseEnter?: () => void;
     label?: string;
+    maxWidth?: DropdownProps['maxWidth'];
+    onClick?: MouseEventHandler;
+    onMouseEnter?: () => void;
+    shortcut?: string;
+    text: string | JSX.Element;
+    type?: DropdownItemType;
 }
 export interface UserListItemProps {
-    img?: string;
-    placeholder?: string;
     avatarSize?: number;
+    img?: string;
     noText?: string;
-    text?: string;
-    renderText?: JSX.Element;
     onClick?: () => void;
+    placeholder?: string;
+    renderText?: JSX.Element;
+    text?: string;
 }
 export interface Dropdown {
     Container: React.FC<DropdownProps>;
     Item: React.FC<DropdownItemProps>;
     Separator: React.FC;
-    UserListItem: React.FC<UserListItemProps>;
     Title: React.FC<TitleProps>;
+    UserListItem: React.FC<UserListItemProps>;
 }
 export interface DefaultDropdownProps {
     closeDropdown: () => void;
     componentId: string;
     content: DropdownItemProps[];
     disableArrowNavigation: boolean;
+    emptyState?: JSX.Element;
     fullWidth: DropdownProps['fullWidth'];
     maxWidth: DropdownProps['maxWidth'];
     rowHasFocus: boolean;
     setHighlightedItem: React.Dispatch<React.SetStateAction<number>>;
-    emptyState?: JSX.Element;
 }
 export interface DropdownTriggerProps {
-    title: string;
     isDisabled?: boolean;
+    title: string;
 }
 export interface StyledItemProps extends Pick<DropdownItemProps, 'fullWidth' | 'maxWidth' | 'active' | 'isDisabled' | 'type'> {
     rowHasFocus: boolean;
 }
+export {};

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

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { DropdownProps } from '../../../dropdown/types';
 import { Unit } from './unitDropdown/UnitDropdownTrigger';
-export interface UnitDropdownProps extends Pick<DropdownProps, 'renderContent' | 'placement' | 'className' | 'triggerStyles' | 'content' | 'maxWidth' | 'minWidthAsTrigger' | 'forceOpen'> {
+export interface UnitDropdownProps extends Pick<DropdownProps, 'renderContent' | 'placement' | 'className' | 'triggerStyles' | 'content' | 'maxWidth' | 'minWidthAsTrigger'> {
     currentUnit: Unit;
 }
 declare const UnitDropdown: ({ currentUnit, ...dropdownProps }: UnitDropdownProps) => JSX.Element;

package/dist/components/form/select/components/LoadingIndicator.d.ts

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

package/dist/components/gridCard/GridCard.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { GridCardProps } from './types';
+declare const _default: React.ForwardRefExoticComponent<GridCardProps & React.RefAttributes<HTMLDivElement>>;
+export default _default;

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

@@ -0,0 +1,7 @@
+import { Meta, Story } from '@storybook/react';
+import { ComponentProps } from 'react';
+import { GridCard } from '.';
+import { GridCardProps } from './types';
+export declare const Template: Story<GridCardProps>;
+declare const GridCardStories: Meta<ComponentProps<typeof GridCard>>;
+export default GridCardStories;

package/dist/components/gridCard/gridCardPalette.d.ts

@@ -0,0 +1,3 @@
+import { GridCardPalette } from './index';
+declare const gridCardPalette: GridCardPalette;
+export default gridCardPalette;

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

@@ -0,0 +1,3 @@
+export { default as GridCard } from './GridCard';
+export { GridCardProps, GridCardPalette } from './types';
+export { default as gridCardPalette } from './gridCardPalette';

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

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

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export declare const StyledGridCard: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & import("../card").StyledCardProps & {
+    children: import("react").ReactNode | import("react").ReactNode[];
+} & import("react").RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {}, never>;
+export declare const GridCardContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+declare type GridCardItemProps = {
+    n: number;
+};
+export declare const GridCardItem: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, GridCardItemProps, never>;
+export {};

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

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { ComponentType } from '../../common/types';
+import { paletteColor } from '../../styles/types';
+import { IconProps } from '../icon';
+export declare type GridCardProps = {
+    items: GridCardItem[];
+    maxElementsPerRow?: number;
+};
+export declare type GridCardPalette = {
+    [key in ComponentType]: {
+        background: paletteColor;
+        iconColor: paletteColor;
+        iconBackground: paletteColor;
+    };
+};
+export declare type GridCardItem = {
+    type: ComponentType;
+    icon?: IconProps;
+    label?: string;
+    content: ReactNode;
+};

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

@@ -0,0 +1,2 @@
+import { DefaultTheme } from 'styled-components';
+export declare const getIconBackgroundColor: (theme: DefaultTheme, iconColor?: string | undefined, customIconBackground?: string | undefined) => string;

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

@@ -4,5 +4,6 @@ import { IconColorPalette } from './iconPalette';
 interface GetIconStylesParams extends IconProps {
     theme: DefaultTheme;
 }
+export declare const isIconPaletteKey: (key: string, theme: DefaultTheme) => key is "black" | "white" | "grey" | "blue" | "indigo" | "yellow" | "orange" | "red" | "green" | "fuchsia" | "pink" | "cyan" | "primary";
 export declare const getIconStyles: ({ theme, color }: GetIconStylesParams) => IconColorPalette;
 export {};

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

@@ -8,4 +8,4 @@ export declare const StyledInlineMessageWrapper: import("styled-components").Sty
 export declare const StyledIconContent: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, StyledContentProps, never>;
 export declare const StyledCloseIconWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledCloseIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
-export declare const ActionButton: 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 ActionButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;

package/dist/components/layout/sidebarItem/components/SidebarItemDropdown.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 import { SidebarItemDropdownProps } from '../types';
-declare const SidebarItemDropdown: ({ className, content, forceOpen }: SidebarItemDropdownProps) => JSX.Element;
+declare const SidebarItemDropdown: ({ className, content }: SidebarItemDropdownProps) => JSX.Element;
 export default SidebarItemDropdown;

package/dist/components/layout/sidebarItem/styled.d.ts

@@ -8,7 +8,7 @@ export interface WrapperProps {
     withoutPadding: boolean;
 }
 export declare const sidebarItemHeight = 44;
-export declare const Dropdown: import("styled-components").StyledComponent<({ className, content, forceOpen }: import("./types").SidebarItemDropdownProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const Dropdown: import("styled-components").StyledComponent<({ className, content }: import("./types").SidebarItemDropdownProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const SidebarItemWrapper: import("styled-components").StyledComponent<"a", import("styled-components").DefaultTheme, SidebarItemStyles & WrapperProps, keyof SidebarItemStyles>;
 export declare const Title: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const NoIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
 export declare const Container: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const MonthSelectionArea: import("styled-components").StyledComponent<import("react").FunctionComponent<import("@viselect/react/dist/SelectionArea").SelectionAreaProps>, import("styled-components").DefaultTheme, {}, never>;
-export declare const SelectAllButton: 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 SelectAllButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;
 export declare const TutorialText: import("styled-components").StyledComponent<({ children, type, ...otherProps }: import("../../common/components/typography/types").TextProps & import("react").HTMLAttributes<HTMLDivElement>) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;

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

@@ -5,7 +5,7 @@ import { TableProps } from './types';
  * @param {T[]} data Array of data to display
  * @param {ColumnsType<T>[]} columns Columns configurations
  * @param {boolean} isSelectable Allow to select rows
- * @param {function} onRowSelectionChange Callback called when rows selection changes
+ * @param {function} onRowSelection Callback called when rows selection changes
  * @param {function} onSort Callback called on column sort change
  * @param {number[]} toggles Array of toggles index
  * @param {function} onTogglesChange Callback called on toggles change
@@ -30,5 +30,5 @@ import { TableProps } from './types';
  * @param {number} actionColumnWidth used to determine the width of the action column
  * @param {function} isRowHighlighted used to underline table rows
  */
-declare const Table: <T>({ data, columns, isSelectable, toggles, onTogglesChange, headerSize, isTogglesSortable, sortable, sortDescFirst, enableSettings, settingsDropdownConfig, rowActions, bulkActions, isLoading, allSelectedCTA, noPagination, pageSize: pageLength, listSize, paginationPreviousText, paginationNextText, onPaginationChange, uniqueId, onSort, renderEmptyState, onRowClick, bodyHeight, totalPages, rowHighlightColor, rowSelection, onRowSelection, forceHideSettings, renderBulkActions, preSettedTableSettings, onChangeTableSettings, notRemovableColumns, rowSize, actionColumnWidth, disableScrollX, resetPageIndex, isRowHighlighted, rowHighlightHideBorderBottom, }: TableProps<T>) => JSX.Element;
+declare const Table: <T>({ data, columns, isSelectable, toggles, onTogglesChange, headerSize, isTogglesSortable, sortable, sortDescFirst, enableSettings, settingsDropdownConfig, rowActions, bulkActions, isLoading, allSelectedCTA, noPagination, pageSize: pageLength, listSize, paginationPreviousText, paginationNextText, onPaginationChange, uniqueId, onSort, renderEmptyState, onRowClick, bodyHeight, totalPages, rowHighlightColor, rowSelection, onRowSelection, forceHideSettings, renderBulkActions, preSettedTableSettings, onChangeTableSettings, notRemovableColumns, rowSize, actionColumnWidth, disableScrollX, resetPageIndex, isRowHighlighted, isRowDisabled, rowHighlightHideBorderBottom, }: TableProps<T>) => JSX.Element;
 export default Table;

package/dist/components/newTable/components/action/settings/ColumnsSettings/styled.d.ts

@@ -1,4 +1,5 @@
-export declare const CustomAccordion: import("styled-components").StyledComponent<import("../../../../../accordions/types").TAccordion, import("styled-components").DefaultTheme, {}, never>;
+/// <reference types="react" />
+export declare const CustomAccordion: import("styled-components").StyledComponent<({ open, setOpen, renderLateralActions, renderTitle, renderBody, title, lateralActions, }: import("../../../../../accordion").AccordionProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const Title: import("styled-components").StyledComponent<"h6", import("styled-components").DefaultTheme, {}, never>;
 export declare const Body: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const Divider: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

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

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { Row } from '@tanstack/react-table';
 import { TableProps } from '../../types';
-interface BodyProps<T> extends Pick<TableProps<T>, 'rowSize' | 'bodyHeight' | 'rowHighlightColor' | 'isRowHighlighted' | 'rowHighlightHideBorderBottom'> {
+interface BodyProps<T> extends Pick<TableProps<T>, 'rowSize' | 'bodyHeight' | 'rowHighlightColor' | 'isRowHighlighted' | 'rowHighlightHideBorderBottom' | 'isRowDisabled'> {
     rows: Row<T>[];
     isLoading?: boolean;
     onRowClick?: (row: Row<T>) => void;
@@ -9,5 +9,5 @@ interface BodyProps<T> extends Pick<TableProps<T>, 'rowSize' | 'bodyHeight' | 'r
     actionColumnWidth: number;
     disableScrollX?: boolean;
 }
-declare const Body: <T>({ rows, rowSize, isLoading, onRowClick, bodyHeight, rowHighlightColor, pageIndex, actionColumnWidth, disableScrollX, isRowHighlighted, rowHighlightHideBorderBottom, }: BodyProps<T>) => JSX.Element;
+declare const Body: <T>({ rows, rowSize, isLoading, onRowClick, bodyHeight, rowHighlightColor, pageIndex, actionColumnWidth, disableScrollX, isRowHighlighted, isRowDisabled, rowHighlightHideBorderBottom, }: BodyProps<T>) => JSX.Element;
 export default Body;

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

@@ -2,13 +2,14 @@
 import { Cell as TCell, Row } from '@tanstack/react-table';
 import { RowSize } from '../../types';
 interface Props<T> {
+    actionColumnWidth: number;
     cell: TCell<T, unknown>;
-    row: Row<T>;
     hover?: boolean;
-    rowSize?: RowSize;
     isLoading?: boolean;
+    disableRow: boolean;
     onRowClick?: (row: Row<T>) => void;
-    actionColumnWidth: number;
+    row: Row<T>;
+    rowSize?: RowSize;
 }
-declare const Cell: <T>({ cell, row, hover, rowSize, isLoading, onRowClick, actionColumnWidth }: Props<T>) => JSX.Element;
+declare const Cell: <T>({ actionColumnWidth, cell, disableRow, hover, isLoading, onRowClick, row, rowSize, }: Props<T>) => JSX.Element;
 export default Cell;

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

@@ -2,13 +2,14 @@
 import { Column, Row } from '@tanstack/react-table';
 import { ActionColumnDef, ActionType } from '../../../types';
 interface Props<T> extends ActionColumnDef<T> {
-    row: Row<T>;
+    actionColumnWidth: number;
     actionType: ActionType;
-    isToggled?: boolean;
     column: Column<T, unknown>;
+    disableRow: boolean;
+    isToggled?: boolean;
     maxWidth?: number;
     minWidth?: number;
-    actionColumnWidth: number;
+    row: Row<T>;
 }
-declare const CustomActionCell: <T>({ actionType, row, isToggled, onActionChange, rowActions, column, maxWidth, minWidth, actionColumnWidth, }: Props<T>) => JSX.Element;
+declare const CustomActionCell: <T>({ actionColumnWidth, actionType, column, disableRow, isToggled, maxWidth, minWidth, onActionChange, row, rowActions, }: Props<T>) => JSX.Element;
 export default CustomActionCell;

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

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

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

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

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<({ 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 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>;

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

@@ -2,12 +2,13 @@
 import { CellContext, Row } from '@tanstack/react-table';
 import { AccessorColumnDef, ActionColumnDef, AdditionalColumnDef, CustomCellProps, RowSize } from '../../../types';
 declare type Props<CellProps> = {
-    row: Row<CellProps>;
+    actionColumnWidth: number;
     context: CellContext<CellProps, unknown>;
+    disableRow: boolean;
     hover?: boolean;
-    rowSize?: RowSize;
-    actionColumnWidth: number;
     onRowClick?: (row: Row<CellProps>) => void;
+    row: Row<CellProps>;
+    rowSize?: RowSize;
 } & CustomCellProps & AccessorColumnDef<CellProps> & ActionColumnDef<CellProps> & AdditionalColumnDef<CellProps>;
-declare const CustomCell: <CellProps>({ content, isEditable, tag, unitSymbol, headline, leadingIcon, avatar, actionType, row, rowSize, onActionChange, isToggled, hover, onChange, trailingMicroTag, minWidth, rowActions, context, onRowClick, maxWidth, align, disableClick, actionColumnWidth, }: Props<CellProps>) => JSX.Element;
+declare const CustomCell: <CellProps>({ actionColumnWidth, actionType, align, avatar, content, context, disableClick, disableRow, headline, hover, isEditable, isToggled, leadingIcon, maxWidth, minWidth, onActionChange, onChange, onRowClick, row, rowActions, rowSize, tag, trailingMicroTag, unitSymbol, }: Props<CellProps>) => JSX.Element;
 export default CustomCell;

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

@@ -1,22 +1,12 @@
 /// <reference types="react" />
 import { HeaderGroup } from '@tanstack/react-table';
-import { onChangeTableSettings, OnSort, RowSize } from '../../types';
-interface HeaderProps<T> {
-    headerGroup: HeaderGroup<T>[];
-    headerSize?: RowSize;
-    onSort?: OnSort<T>;
+import { TableProps } from '../../types';
+interface HeaderProps<T> extends Pick<TableProps<T>, 'isRowDisabled' | 'headerSize' | 'notRemovableColumns' | 'onChangeTableSettings' | 'onSort' | 'preSettedTableSettings' | 'rowSelection'> {
+    actionColumnWidth: number;
     forceHideSettings: boolean;
-    rowSelection?: string[];
-    setRowSelection?: (e: string[]) => void;
-    preSettedTableSettings?: {
-        orderColumns?: string[];
-        dimensionRow?: number;
-        notVisibleColumns?: string[];
-    };
-    notRemovableColumns?: string[];
-    onChangeTableSettings?: onChangeTableSettings;
+    headerGroup: HeaderGroup<T>[];
     isLoading: boolean;
-    actionColumnWidth: number;
+    setRowSelection?: (e: string[]) => void;
 }
 declare const Header: <T>({ headerGroup, headerSize, onSort, forceHideSettings, rowSelection, setRowSelection, preSettedTableSettings, onChangeTableSettings, notRemovableColumns, isLoading, actionColumnWidth, }: HeaderProps<T>) => JSX.Element;
 export default Header;