@fattureincloud/fic-design-system 0.14.5 → 0.15.1

package/dist/components/newTable_v2/customCells/DateCell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ParsableDateTime, ValidFormat } from '@fattureincloud/madbit-js-dates';
+declare type Props = {
+    date: ParsableDateTime;
+    format: ValidFormat;
+    locale: 'en' | 'es' | 'it';
+};
+declare const DateCell: (props: Props) => JSX.Element;
+export default DateCell;

package/dist/components/newTable_v2/customCells/MicroTagCell.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { MicroTagProps } from '../../microTag';
+declare type ConversionFnProps<T> = {
+    row: Row<T>;
+    convertToProps: (row: Row<T>) => MicroTagProps;
+};
+declare type Props<T> = MicroTagProps | ConversionFnProps<T>;
+declare const MicroTagCell: <T>(props: Props<T>) => JSX.Element;
+export default MicroTagCell;

package/dist/components/newTable_v2/customCells/TagCell.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { TagProps } from '../../tag';
+declare type ConversionFnProps<T> = {
+    row: Row<T>;
+    convertToProps: (row: Row<T>) => TagProps;
+};
+declare type Props<T> = TagProps | ConversionFnProps<T>;
+declare const TagCell: <T>(props: Props<T>) => JSX.Element;
+export default TagCell;

package/dist/components/newTable_v2/customCells/TwoRowsCell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { IconProps } from '../../icon';
+declare type Props = {
+    icon?: IconProps;
+    mainText?: string;
+    subText?: string;
+};
+declare const NameVatTableCell: ({ icon, mainText, subText }: Props) => JSX.Element;
+export default NameVatTableCell;

package/dist/components/newTable_v2/customCells/ValueWithUnitCell.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { UnitConfig } from '../../../common/utils/stringUtils';
+import { CellValue } from '../types';
+declare type Props = {
+    value: CellValue;
+    unit: UnitConfig;
+};
+declare const ValueWithUnitCell: ({ unit, value }: Props) => JSX.Element;
+export default ValueWithUnitCell;

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

@@ -0,0 +1,4 @@
+export { default as DateCell } from './DateCell';
+export { default as MicroTagCell } from './MicroTagCell';
+export { default as TagCell } from './TagCell';
+export { default as ValueWithUnitCell } from './ValueWithUnitCell';

package/dist/components/newTable_v2/hooks/useClassNames.d.ts

@@ -0,0 +1,6 @@
+import { TableComponent } from '../types';
+declare type ClassNames<K extends TableComponent> = {
+    [P in K as `${P}ClassName`]: string;
+};
+declare const useClassNames: <K extends TableComponent>(...components: K[]) => ClassNames<K>;
+export default useClassNames;

package/dist/components/newTable_v2/hooks/useColumnHelper.d.ts

@@ -0,0 +1,7 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { CellValue, ColumnsType } from '../types';
+declare type ColumnsHelperProps<T> = {
+    columns: ColumnsType<T>[];
+};
+declare const useColumnsHelper: <T>({ columns }: ColumnsHelperProps<T>) => ColumnDef<T, CellValue>[];
+export default useColumnsHelper;

package/dist/components/newTable_v2/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_v2/hooks/usePagination.d.ts

@@ -0,0 +1,8 @@
+import { PaginationState } from '@tanstack/react-table';
+import { Dispatch, SetStateAction } from 'react';
+interface ReturnType {
+    pagination: PaginationState;
+    setPagination: Dispatch<SetStateAction<PaginationState>>;
+}
+export declare const usePagination: (size: number | undefined) => ReturnType;
+export {};

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

@@ -0,0 +1,3 @@
+export { default as NewTable } from './Table';
+export * from './types';
+export * from './customCells';

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TableContextProps, TableProviderProps } from './types';
+export declare const TableContext: React.Context<TableContextProps>;
+declare const TableProvider: <T>({ absoluteElementsPortal, actionColumnWidth, children, columns, columnsSettings: initialColumnsSettings, enableSettings, hideableColumns, isLoading, isSelectable, loadingStyle, onSettingsChange, rowActions, rowSize: initialRowSize, settingsLabels, settingsTooltip, sortableColumns, }: TableProviderProps<T>) => JSX.Element;
+export default TableProvider;

package/dist/components/newTable_v2/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_v2/providers/TableProvider/types.d.ts

@@ -0,0 +1,27 @@
+import { Dispatch, ReactNode, SetStateAction } from 'react';
+import { TooltipProps } from '../../../tooltip';
+import { ColumnsSettings, LoadingStyle, RowSize, SettingsLabels, TableProps, TableSettings } from '../../types';
+export declare type ImmutableContext = {
+    absoluteElementsPortal?: HTMLElement;
+    loadingStyle?: LoadingStyle;
+    tableID: string;
+    enableSettings: boolean;
+    hideableColumns: string[];
+    settingsLabels: Required<SettingsLabels>;
+    settingsTooltip: TooltipProps;
+    sortableColumns: string[];
+};
+export declare type TableContextProps = ImmutableContext & {
+    actionColumnWidth: number;
+    hasActions: boolean;
+    hasCheckbox: boolean;
+    isLoading: boolean;
+    rowSize: RowSize;
+    setRowSize: Dispatch<SetStateAction<RowSize>>;
+    columnsSettings: Required<ColumnsSettings>;
+    setColumnsSettings: Dispatch<SetStateAction<Required<ColumnsSettings>>>;
+    onSettingsChange?: TableSettings['onSettingsChange'];
+};
+export declare type TableProviderProps<T> = TableProps<T> & {
+    children: ReactNode | ReactNode[];
+};

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

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

package/dist/components/newTable_v2/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_v2/stories/data.d.ts

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

package/dist/components/newTable_v2/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_v2/stories/types.d.ts

@@ -0,0 +1,10 @@
+import { CellValue } from '../types';
+export interface DataType {
+    id: string;
+    rowStatus?: 'highlighted';
+    supplier: CellValue;
+    description: CellValue;
+    payment: CellValue;
+    amount: CellValue;
+    date: CellValue;
+}

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

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

package/dist/components/newTable_v2/table.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_v2/types/cellsTypes.d.ts

@@ -0,0 +1 @@
+export declare type CellValue = Record<string, unknown> | boolean | string | number | null | undefined;

package/dist/components/newTable_v2/types/columnsTypes.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="react" />
+import { DisplayColumnDef as RTDisplayColumnDef, GroupColumnDef as RTGroupColumnDef, IdentifiedColumnDef, Row } from '@tanstack/react-table';
+import { InputTextProps } from '../../form/inputText';
+import { TooltipProps } from '../../tooltip';
+import { CellValue } from './cellsTypes';
+import { ColumnDefType } from './enums';
+export declare type BaseColumnsType<T> = {
+    columnDef: BaseColumnDef<T>;
+    columnDefType: ColumnDefType;
+    key: keyof T & string;
+};
+export declare type BaseColumnDef<T> = IdentifiedColumnDef<T> & {
+    align?: 'center' | 'left' | 'right';
+    customCell?: (row: Row<T>, hasHover: boolean) => JSX.Element;
+    disableClick?: boolean;
+    header?: IdentifiedColumnDef<T, CellValue>['header'] | JSX.Element;
+    headerTooltip?: TooltipProps;
+    id?: string;
+    maxWidth?: number;
+    minWidth?: number;
+    multiline?: boolean;
+};
+export declare type EditableCellsColumn<T> = {
+    inputProps?: Omit<InputTextProps, 'value' | 'setValue'>;
+    onChange: (text: string, row: Row<T>) => void;
+};
+declare type StandardCellsColumn = {
+    inputProps?: never;
+    onChange?: never;
+};
+export declare type AccessorColumnDef<T> = IdentifiedColumnDef<T, CellValue> & BaseColumnDef<T> & (EditableCellsColumn<T> | StandardCellsColumn);
+export declare type AccessorColumn<T> = BaseColumnsType<T> & {
+    columnDefType: ColumnDefType.ACCESSOR;
+    columnDef: AccessorColumnDef<T>;
+};
+export declare type DisplayColumnDef<T> = RTDisplayColumnDef<T, CellValue> & BaseColumnDef<T>;
+export declare type DisplayColumn<T> = BaseColumnsType<T> & {
+    columnDefType: ColumnDefType.DISPLAY;
+    columnDef: DisplayColumnDef<T> & BaseColumnDef<T>;
+};
+export declare type GroupColumnDef<T> = RTGroupColumnDef<T, CellValue>;
+export declare type GroupColumn<T> = BaseColumnsType<T> & {
+    columnDefType: ColumnDefType.GROUP;
+    columnDef: GroupColumnDef<T>;
+};
+export declare type ColumnDef<T> = AccessorColumnDef<T> | DisplayColumnDef<T> | GroupColumnDef<T>;
+export declare type ColumnsType<T> = AccessorColumn<T> | DisplayColumn<T> | GroupColumn<T>;
+export {};

package/dist/components/newTable_v2/types/enums.d.ts

@@ -0,0 +1,16 @@
+export declare enum RowSize {
+    SMALL,
+    LARGE
+}
+export declare enum ColumnDefType {
+    ACCESSOR = "accessor",
+    DISPLAY = "display",
+    GROUP = "group",
+    ACTION = "action"
+}
+export declare enum ActionType {
+    CHECKBOX = "checkbox",
+    TOGGLE = "toggle",
+    ROW_ACTIONS = "row_actions",
+    SETTINGS = "settings"
+}

package/dist/components/newTable_v2/types/features/actions.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { RequireAtLeastOne } from '../../../../common/types';
+import { ButtonProps } from '../../../buttons';
+import { buttonColors } from '../../../buttons/button/types';
+import { DropdownItemProps } from '../../../dropdown';
+import { IconProps } from '../../../icon';
+import { TooltipProps } from '../../../tooltip';
+export declare type TableActions<T> = {
+    actionsHeader?: string | JSX.Element;
+    rowActions?: RowActions<T> | ((row: Row<T>) => RowActions<T>);
+    bulkActions?: BulkAction[];
+    renderBulkActions?: (rows: string[]) => JSX.Element;
+};
+export interface RowActions<T> {
+    primary?: PrimaryAction<T>[];
+    dropdown?: DropdownActions<T>;
+}
+declare type BaseAction = {
+    icon?: IconProps;
+    text?: string;
+};
+export declare type PrimaryAction<T> = RequireAtLeastOne<BaseAction> & {
+    className?: string;
+    color?: buttonColors;
+    onClick: (row: Row<T>) => void;
+    tooltip?: TooltipProps;
+};
+export declare type TableActionsDropdowItem<T> = DropdownItemProps & {
+    onClick: (row: Row<T>) => void;
+};
+export declare type DropdownActions<T> = {
+    items: TableActionsDropdowItem<T>[];
+    tooltip?: TooltipProps;
+};
+export interface BulkAction extends Omit<ButtonProps, 'onClick' | 'text'> {
+    onClick: (rows: string[]) => void;
+    text: string | JSX.Element;
+}
+export {};

package/dist/components/newTable_v2/types/features/highlight.d.ts

@@ -0,0 +1,5 @@
+import { Row } from '@tanstack/react-table';
+export declare type HighlightRow<T> = {
+    isRowHighlighted?: (row: Row<T>) => boolean;
+    rowHighlightColor?: string;
+};

package/dist/components/newTable_v2/types/features/pagination.d.ts

@@ -0,0 +1,20 @@
+import { PaginationState } from '@tanstack/react-table';
+export declare type PaginatedTable = {
+    noPagination?: false;
+    pageSize: number;
+    listSize: number;
+    paginationPreviousText?: string;
+    paginationNextText?: string;
+    onPaginationChange: (pagination: PaginationState) => void;
+    totalPages: number;
+    resetPageIndex?: boolean;
+} | {
+    noPagination: true;
+    pageSize?: never;
+    listSize?: never;
+    paginationPreviousText?: never;
+    paginationNextText?: never;
+    onPaginationChange?: never;
+    totalPages?: never;
+    resetPageIndex?: never;
+};

package/dist/components/newTable_v2/types/features/selectRow.d.ts

@@ -0,0 +1,16 @@
+export declare type AllSelectedCTA = {
+    description?: string;
+    onClick: () => void;
+    text: string;
+};
+export declare type SelectableTable = {
+    isSelectable: true;
+    rowSelection: string[];
+    onRowSelection: (e: string[]) => void;
+    allSelectedCTA?: AllSelectedCTA;
+} | {
+    isSelectable?: false;
+    rowSelection?: never;
+    onRowSelection?: never;
+    allSelectedCTA?: never;
+};

package/dist/components/newTable_v2/types/features/settings.d.ts

@@ -0,0 +1,27 @@
+import { VisibilityState } from '@tanstack/react-table';
+import { TooltipProps } from '../../../tooltip';
+import { RowSize } from '../enums';
+export declare type ColumnsSettings = {
+    order?: string[];
+    visible?: VisibilityState;
+};
+export declare type VariableSettings = {
+    rowSize?: RowSize;
+    columnsSettings?: ColumnsSettings;
+};
+export declare type SettingsLabels = {
+    main?: string;
+    rowSizeLabel?: string;
+    rowSizeSmallLabel?: string;
+    rowSizeLargeLabel?: string;
+    columnsLabel?: string;
+};
+export declare type SettingsEvent = 'resizeRow' | 'hideColumn' | 'showColumn' | 'moveColumn';
+export declare type TableSettings = VariableSettings & {
+    enableSettings?: boolean;
+    settingsLabels?: SettingsLabels;
+    settingsTooltip?: TooltipProps;
+    onSettingsChange?: (event: SettingsEvent, settings: VariableSettings) => void;
+    hideableColumns?: string[];
+    sortableColumns?: string[];
+};

package/dist/components/newTable_v2/types/features/sort.d.ts

@@ -0,0 +1,15 @@
+import { SortDirection } from '@tanstack/react-table';
+export declare type OnSort<T> = (sortParams: {
+    sortBy: keyof T;
+    direction: false | SortDirection;
+}) => void;
+export declare type SortableTable<T> = {
+    sortable: true;
+    sortDescFirst?: boolean;
+    onSort?: OnSort<T>;
+} | {
+    sortable?: false;
+    sortDescFirst?: never;
+    onSort?: never;
+};
+export declare type CustomSorted = Record<string, false | SortDirection>;

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

@@ -0,0 +1,10 @@
+export * from './cellsTypes';
+export * from './columnsTypes';
+export * from './enums';
+export * from './tableTypes';
+export * from './features/actions';
+export * from './features/highlight';
+export * from './features/pagination';
+export * from './features/selectRow';
+export * from './features/settings';
+export * from './features/sort';

package/dist/components/newTable_v2/types/tableTypes.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import { Row } from '@tanstack/react-table';
+import { ColumnsType } from './columnsTypes';
+import { RowSize } from './enums';
+import { TableActions } from './features/actions';
+import { HighlightRow } from './features/highlight';
+import { PaginatedTable } from './features/pagination';
+import { SelectableTable } from './features/selectRow';
+import { TableSettings } from './features/settings';
+import { SortableTable } from './features/sort';
+export declare type TableProps<T> = SelectableTable & PaginatedTable & SortableTable<T> & TableSettings & HighlightRow<T> & TableActions<T> & {
+    absoluteElementsPortal?: HTMLElement;
+    actionColumnWidth?: number;
+    bodyHeight?: number;
+    columns: ColumnsType<T>[];
+    data: T[];
+    headerSize?: RowSize;
+    isLoading?: boolean;
+    isRowDisabled?: (row: Row<T>) => boolean;
+    loadingStyle?: LoadingStyle;
+    onRowClick?: (row: Row<T>) => void;
+    renderEmptyState?: () => JSX.Element;
+    rowTooltip?: (row: Row<T>) => string;
+    showFooter?: boolean;
+    uniqueId: keyof T;
+};
+export declare type LoadingStyle = {
+    backgroundColor?: string;
+    foregroundColor?: string;
+    height?: number | string;
+    width?: number | string;
+};
+export declare type TableComponent = 'tableContainer' | 'table' | 'paginator' | 'tableBody' | 'tableRow' | 'bulkBar' | 'bulkBarContent' | 'bulkBarActions' | 'tableFooter' | 'tableFooterRow' | 'tableFooterCell' | 'tableHeader' | 'tableHeaderRow' | 'tableHeaderCell';

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

@@ -0,0 +1,18 @@
+import { SortDirection } from '@tanstack/react-table';
+import { DefaultTheme } from 'styled-components';
+import { ColumnsType } from './types';
+export declare const getNextSortingDirection: (direction?: false | SortDirection | undefined) => false | SortDirection;
+declare type MapBackgrounProps = {
+    isDisabled: boolean;
+    isRowHighlighted?: boolean;
+    rowHighlightColor?: string;
+    selected: boolean;
+    theme: DefaultTheme;
+};
+export declare type MappedProps = {
+    backgroundColor: string;
+    backgroundHover: string;
+};
+export declare const mapBackground: ({ isDisabled, isRowHighlighted, rowHighlightColor, selected, theme, }: MapBackgrounProps) => MappedProps;
+export declare const getColumnId: <T>(column: ColumnsType<T>) => string;
+export {};

package/dist/components/progressbar/ProgressBar.d.ts

@@ -1,9 +1,13 @@
-import React from 'react';
+/// <reference types="react" />
 import { ProgressBarProps } from './types';
 /**
  * Component Props:
- * @param {ProgressBarType} color Used to set the colors of the component
- * @param {number} percentage Numeric value used to set the progress bar percentage value
+ * @param {string} [className] - Used to style the component with styled-components or a CSS
+ * @param {number} percentage - Numeric value used to set the progress bar percentage value
+ * @param {ProgressBarSize} [size] - The dimension of the progress bar, default MEDIUM
+ * @param {Record<number, ComponentType>} [steps] - Choose the type and color of the progress bar based on the percentage
+ * @param {CSSProperties} [style] - CSS object used to style the component
+ * @param {ComponentType} [type] - Choose the type and color of the progress bar
  */
-declare const ProgressBar: (props: ProgressBarProps) => React.JSX.Element;
+declare const ProgressBar: ({ percentage, size, steps, type, ...rest }: ProgressBarProps) => JSX.Element;
 export default ProgressBar;

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

@@ -1,3 +1,3 @@
 export { default as ProgressBar } from './ProgressBar';
-export { ProgressBarProps, ProgressBarPalette, ProgressBarType } from './types';
+export { ProgressBarProps, ProgressBarPalette, ProgressBarSize } from './types';
 export { default as progressBarPalette } from './progressBarPalette';

package/dist/components/progressbar/progressBar.stories.d.ts

@@ -1,10 +1,6 @@
 import { Meta, Story } from '@storybook/react';
-import React, { ComponentProps } from 'react';
-import { ProgressBar } from '.';
-import { ProgressBarProps } from './';
+import { ComponentProps } from 'react';
+import { ProgressBar, ProgressBarProps } from '.';
 export declare const Template: Story<ProgressBarProps>;
-export declare const Editable: () => React.JSX.Element;
-export declare const Autocomplete: () => React.JSX.Element;
-export declare const AllColors: () => React.JSX.Element;
 declare const ProgressBarStories: Meta<ComponentProps<typeof ProgressBar>>;
 export default ProgressBarStories;

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

@@ -1,3 +1,9 @@
-import { ProgressBarProps } from './types';
-export declare const ProgressContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
-export declare const ProgressionBar: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ProgressBarProps, never>;
+import { ComponentType } from '../../common/types';
+import { ProgressBarSize } from './types';
+declare type BarProps = {
+    percentage: number;
+    pbsize: ProgressBarSize;
+    type: ComponentType;
+};
+export declare const Bar: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, BarProps, never>;
+export {};

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

@@ -1,17 +1,30 @@
+import { CSSProperties } from 'react';
+import { ComponentType } from '../../common/types';
 import { paletteColor } from '../../styles/types';
-export declare enum ProgressBarType {
-    GREY = "grey",
-    RED = "red",
-    BLUE = "blue",
-    YELLOW = "yellow",
-    GREEN = "green"
+export declare enum ProgressBarSize {
+    SMALL = 4,
+    MEDIUM = 8,
+    LARGE = 12
 }
-export interface ProgressBarProps {
-    color?: ProgressBarType;
+declare type CommonProps = {
+    className?: string;
     percentage: number;
-}
-export declare type ProgressBarPalette = {
-    [key in ProgressBarType]: {
-        backgroundColor: paletteColor;
-    };
+    size?: ProgressBarSize;
+    style?: CSSProperties;
+};
+declare type FixedTypeProps = CommonProps & {
+    steps?: never;
+    type: ComponentType;
+};
+declare type AutomaticTypeProps = CommonProps & {
+    steps: Record<number, ComponentType>;
+    type?: never;
+};
+export declare type ProgressBarProps = FixedTypeProps | AutomaticTypeProps;
+declare type ProgressBarPaletteConfig = {
+    backgroundColor: paletteColor;
+    borderColor: paletteColor;
+    barColor: paletteColor;
 };
+export declare type ProgressBarPalette = Record<ComponentType, ProgressBarPaletteConfig>;
+export {};

package/dist/components/switch/Switch.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 import { SwitchProps } from '.';
-declare const Switch: ({ checked, color, onChange, disabled }: SwitchProps) => JSX.Element;
+declare const Switch: ({ checked, color, disabled, onChange }: SwitchProps) => JSX.Element;
 export default Switch;

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

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { TagParts } from './tagPalette';
 import { StyledTagProps } from './types';
-export declare const LeftIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
-export declare const RightIcon: import("styled-components").StyledComponent<({ onClick, isDisabled, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const LeftIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export declare const RightIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const Text: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledTag: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, TagParts & StyledTagProps, import("./tagPalette").tagParts>;

package/dist/components/toast/components/ToastContent.d.ts

@@ -5,7 +5,7 @@ export declare const StyledHeader: import("styled-components").StyledComponent<"
 export declare const ActionButton: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../../buttons").ButtonProps & import("react").RefAttributes<HTMLDivElement | HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledIconContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledTitle: 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, {}, never>;
+export declare const StyledIcon: import("styled-components").StyledComponent<({ isDisabled, onClick, ...props }: import("../../icon").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
 export declare const StyledTitleText: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
     type: ToastType;
 }, never>;

package/dist/components/tooltip/Tooltip.d.ts

@@ -1,23 +1,5 @@
-import { BasePlacement } from '@popperjs/core';
-import { MouseEventHandler, ReactNode } from 'react';
-import { IconProps } from '../icon';
-import { MessageProps } from './components/Message';
+/// <reference types="react" />
+import { TooltipProps } from './types';
 export declare const defaultTooltipProps: TooltipProps;
-export interface TooltipProps extends MessageProps {
-    callbackAfterTimeout?: () => void;
-    children?: ReactNode;
-    className?: string;
-    hideAfterSeconds?: number;
-    icon?: IconProps;
-    message: string | JSX.Element;
-    onMouseEnter?: MouseEventHandler;
-    onMouseLeave?: MouseEventHandler;
-    onOpen?: (isOpen: boolean) => void;
-    placement: BasePlacement;
-    renderButton?: () => JSX.Element;
-    showAfterSeconds?: number;
-    showAlways?: boolean;
-    shouldRender?: boolean;
-}
-declare const Tooltip: ({ message, placement, className, children, type, onMouseEnter, onMouseLeave, showAlways, showAfterSeconds, hideAfterSeconds, callbackAfterTimeout, onOpen, icon, renderButton, shouldRender, }: TooltipProps) => JSX.Element;
+declare const Tooltip: ({ callbackAfterTimeout, children, className, hideAfterSeconds, icon, message, onMouseEnter, onMouseLeave, onOpen, placement, positionStrategy, renderButton, shouldRender, showAfterSeconds, showAlways, style, type, }: TooltipProps) => JSX.Element;
 export default Tooltip;

package/dist/components/tooltip/TooltipPopup.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { TooltipProps } from './types';
+import { UseTooltipValue } from './useTooltip';
+declare type TooltipPopupProps<W extends HTMLElement, C extends HTMLElement> = Pick<TooltipProps, 'icon' | 'message' | 'renderButton' | 'type'> & Pick<UseTooltipValue<W, C>, 'showTooltip' | 'popperRef' | 'styles' | 'setArrowRef' | 'attributes'> & {
+    shouldRender: boolean;
+};
+declare const TooltipPopup: <W extends HTMLElement, C extends HTMLElement>({ attributes, icon, message, popperRef, renderButton, setArrowRef, shouldRender, showTooltip, styles, type, }: TooltipPopupProps<W, C>) => JSX.Element;
+export default TooltipPopup;