@zextras/carbonio-design-system 0.3.10 → 0.4.0-devel.1663244158706

package/dist/zapp-ui.bundle.d.ts

@@ -0,0 +1,1917 @@
+import { ButtonHTMLAttributes } from 'react';
+import { CSSProperties } from 'react';
+import DatePicker from 'react-datepicker';
+import { DefaultTheme } from 'styled-components';
+import { ErrorInfo } from 'react';
+import { FlattenSimpleInterpolation } from 'styled-components';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { InputHTMLAttributes } from 'react';
+import { Placement } from '@popperjs/core/lib/enums';
+import { Placement as Placement_2 } from '@popperjs/core';
+import { PropsWithoutRef } from 'react';
+import { default as React_2 } from 'react';
+import { ReactDatePickerProps } from 'react-datepicker';
+import { RefAttributes } from 'react';
+import { StyledComponent } from 'styled-components';
+import { SVGAttributes } from 'react';
+import { ThemeContext } from 'styled-components';
+
+export declare const Accordion: React_2.ForwardRefExoticComponent<AccordionProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare type AccordionDivider = {
+    divider: true;
+};
+
+export declare const AccordionItem: React_2.ForwardRefExoticComponent<AccordionItemProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface AccordionItemProps extends ContainerProps {
+    item: AccordionItemType;
+    children?: React_2.ReactNode | React_2.ReactNode[];
+}
+
+export declare type AccordionItemType = {
+    id: string;
+    label?: string;
+    items?: AccordionItemType[];
+    onClick?: (event: KeyboardEvent | React_2.SyntheticEvent) => void;
+    icon?: keyof ThemeObj['icons'];
+    CustomComponent?: React_2.ComponentType<{
+        item: AccordionItemType;
+    }>;
+    iconCustomColor?: string;
+    iconColor?: string;
+    badgeType?: 'read' | 'unread';
+    badgeCounter?: number;
+    open?: boolean;
+    background?: keyof ThemeObj['palette'];
+    disableHover?: boolean;
+    active?: boolean;
+    level?: number;
+    textProps?: TextProps;
+    onOpen?: (e: React_2.SyntheticEvent | KeyboardEvent) => void;
+    onClose?: (e: React_2.SyntheticEvent | KeyboardEvent) => void;
+};
+
+export declare interface AccordionProps extends ContainerProps {
+    /** Items tree object, can be nested (each property is forwarded to the item component as a prop) */
+    items: Array<AccordionItemType | AccordionDivider>;
+    /** Depth level, internally used for recursion nesting */
+    level?: number;
+    /** Accordion background */
+    background?: keyof ThemeObj['palette'];
+    /** id of the currently active item (alternative to the active item flag) */
+    activeId?: string;
+    /** list of ids of the currently open items (alternative to the open item flag) */
+    openIds?: string[];
+    /** disable animation of the accordion when expanding folders */
+    disableTransition?: boolean;
+}
+
+export declare type Action = {
+    type?: never;
+    iconType?: IconButtonProps['type'];
+} & IconButtonProps & DropdownItem;
+
+export declare const Avatar: React_2.ForwardRefExoticComponent<AvatarPropTypes & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface AvatarPropTypes extends HTMLAttributes<HTMLDivElement> {
+    /** size of the Avatar circle */
+    size?: keyof ThemeObj['sizes']['avatar'];
+    /** url to the profile picture */
+    picture?: string;
+    /** string to be used as capitals, or for its calculation */
+    label: string;
+    /** string to be used for the background color calculation */
+    colorLabel?: string;
+    /** icon to display instead of the capitals */
+    icon?: string;
+    /** icon to display as capitals fallback */
+    fallbackIcon?: string;
+    /** used to force a background color */
+    background?: string;
+    /** used to force a color for the avatar text/icon color */
+    color?: string;
+    /** avatar selection mode */
+    selecting?: boolean;
+    /** avatar selected */
+    selected?: boolean;
+    /** Shape of the avatar */
+    shape?: ShapeType;
+    /** disabled status */
+    disabled?: boolean;
+}
+
+declare type AvatarSkeletonComponentProps = {
+    variant?: string;
+    radius?: string;
+    size?: keyof typeof SIZES;
+    width?: string;
+};
+
+export declare const Badge: React_2.ForwardRefExoticComponent<BadgeProps & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Badge type */
+    type?: 'read' | 'unread';
+    /** Badge text */
+    value: string | number;
+}
+
+declare type BadgeSkeletonProps = {
+    variant?: string;
+    radius?: string;
+    width?: string;
+    height?: string;
+    size?: keyof typeof SIZES;
+    backgroundSize?: string;
+};
+
+declare type BreadcrumbCollapersProps = {
+    all: string;
+} & PaddingProps;
+
+export declare const Breadcrumbs: React_2.ForwardRefExoticComponent<BreadcrumbsProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface BreadcrumbsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Array of items, check Dropdown items prop to see the shape of an item */
+    crumbs: Crumb[];
+    /** Props to spread to the collapser element */
+    collapserProps?: Omit<BreadcrumbCollapersProps, 'all'>;
+    /** Props to spread to the dropdown element */
+    dropdownProps?: Omit<DropdownProps, 'items' | 'children'>;
+}
+
+export declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+declare type ButtonColorsByType = ({
+    type?: 'default' | 'outlined';
+} & ({
+    /** Main color */
+    color?: string | keyof ThemeObj['palette'];
+} | {
+    /** Background color of the button (only for 'default' and 'outlined' types, to use instead of color for more specificity) */
+    backgroundColor?: string | keyof ThemeObj['palette'];
+    /** Specific color of the content (only for 'default' and 'outlined' types, to use instead of color for more specificity) */
+    labelColor?: string | keyof ThemeObj['palette'];
+})) | {
+    type: 'ghost';
+    /** Main color */
+    color?: string | keyof ThemeObj['palette'];
+};
+
+declare type ButtonIconPlacement = 'left' | 'right';
+
+export declare const ButtonOld: React_2.ForwardRefExoticComponent<ButtonOldProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface ButtonOldProps {
+    /** Type of button */
+    type?: ButtonType;
+    /** Color of button */
+    color?: string | keyof ThemeObj['palette'];
+    /** Color of the Button label */
+    labelColor?: string | keyof ThemeObj['palette'];
+    /** Color of the Button background */
+    backgroundColor?: string | keyof ThemeObj['palette'];
+    /** Button text */
+    label: string;
+    /** `fit`: assume the size of the content
+     *
+     *  `fill`: take the width of the container
+     */
+    size?: 'fit' | 'fill';
+    /** optional icon to display beside the label */
+    icon?: keyof ThemeObj['icons'];
+    /** Icon position */
+    iconPlacement?: 'left' | 'right';
+    /** whether to show the loading icon */
+    loading?: boolean;
+    /** small item size */
+    isSmall?: boolean;
+    /** whether to disable the button or not */
+    disabled?: boolean;
+    /** Callback to be invoked when the button is pressed */
+    onClick: (event: React_2.SyntheticEvent | KeyboardEvent) => void;
+    /** whether to force active status or not */
+    forceActive?: boolean;
+}
+
+export declare type ButtonProps = ButtonPropsInternal & Omit<ButtonHTMLAttributes<HTMLButtonElement>, keyof ButtonPropsInternal>;
+
+declare type ButtonPropsInternal = {
+    /** Force active status */
+    forceActive?: boolean;
+    /** Disabled status */
+    disabled?: boolean;
+    /** Icon to display beside the label */
+    icon?: IconProps['icon'];
+    /** Icon position relative to the label  */
+    iconPlacement?: ButtonIconPlacement;
+    /** Text content of the button */
+    label?: string;
+    /** Whether to show the loading icon */
+    loading?: boolean;
+    /** Main action callback */
+    onClick: (e: React_2.MouseEvent<HTMLButtonElement> | KeyboardEvent) => void;
+    /** Shape of the button */
+    shape?: ButtonShape;
+    /** Width of the button */
+    width?: ButtonWidth;
+} & ({
+    /** Size variant of the button */
+    size?: 'medium' | 'large' | 'extralarge';
+    /** Secondary action object (available only for medium and large buttons) */
+    secondaryAction?: ButtonSecondaryAction;
+} | {
+    /** Size variant of the button */
+    size?: ButtonSize;
+    secondaryAction?: undefined;
+}) & ButtonColorsByType;
+
+export declare interface ButtonSecondaryAction {
+    /** Icon of the secondary action */
+    icon: IconProps['icon'];
+    /** Callback for the secondary action */
+    onClick: (e: React_2.MouseEvent<HTMLButtonElement> | KeyboardEvent) => void;
+    /** Disabled status for the secondary action */
+    disabled?: boolean;
+    /** forceActive status for the secondary action */
+    forceActive?: boolean;
+    /** Ref object to assign to secondary button */
+    ref?: React_2.RefObject<HTMLButtonElement>;
+}
+
+declare type ButtonShape = 'regular' | 'round';
+
+declare type ButtonSize = 'extrasmall' | 'small' | 'medium' | 'large' | 'extralarge';
+
+declare type ButtonSkeletonProps = {
+    variant: string;
+    radius: string;
+    size: keyof typeof SIZES;
+    width: string;
+    height: string;
+};
+
+declare type ButtonType = 'default' | 'outlined' | 'ghost';
+
+declare type ButtonWidth = 'fit' | 'fill';
+
+export declare class Catcher extends React_2.Component<CatcherProps, CatcherState> {
+    constructor(props: CatcherProps);
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): React_2.ReactNode;
+}
+
+export declare interface CatcherProps {
+    /** error callback, use this to perform operations when an error is caught */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+
+declare interface CatcherState {
+    hasError: boolean;
+    error: Error | null;
+}
+
+export declare const Checkbox: React_2.ForwardRefExoticComponent<CheckboxProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface CheckboxProps extends Omit<ContainerProps, 'onChange' | 'onClick'> {
+    /** status of the Checkbox */
+    defaultChecked?: boolean;
+    /** Checkbox value */
+    value?: boolean;
+    /** Checkbox size
+     * @deprecated use size instead
+     */
+    iconSize?: keyof ThemeObj['sizes']['icon'];
+    /** Checkbox color */
+    iconColor?: keyof ThemeObj['palette'] | string;
+    /** Checkbox text */
+    label?: string;
+    /** Checkbox padding */
+    padding?: ContainerProps['padding'];
+    /** whether to disable the checkbox or not */
+    disabled?: boolean;
+    /** click callback */
+    onClick?: (event: Event) => void;
+    /** change callback */
+    onChange?: (checked: boolean) => void;
+    /** available sizes */
+    size?: CheckboxSize;
+}
+
+declare type CheckboxSize = 'medium' | 'small';
+
+export declare const Chip: React_2.ForwardRefExoticComponent<ChipProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare type ChipAction = {
+    /** Chip action icon color */
+    color?: keyof ThemeObj['palette'];
+    /** Chip action disabled status */
+    disabled?: boolean;
+    /** Chip action icon */
+    icon: keyof ThemeObj['icons'];
+    /** Chip action id (required for key attribute) */
+    id: string;
+    /** Chip action label value. It is shown in a tooltip. To not render the tooltip, just don't value the prop.
+     * Tooltips of the actions are not shown in case the chip is disabled */
+    label?: string;
+} & ({
+    /** Chip action type */
+    type: 'button';
+    /** Chip action click callback (button type only). NB: onClick event IS propagated. It's up to the dev to eventually stop the propagation */
+    onClick: IconButtonProps['onClick'];
+    /** Chip action background (button type only) */
+    background?: keyof ThemeObj['palette'];
+} | {
+    /** Chip action type */
+    type: 'icon';
+});
+
+export declare type ChipInput = React_2.ForwardRefExoticComponent<ChipInputProps & React_2.RefAttributes<HTMLDivElement>> & {
+    _newId?: number;
+};
+
+export declare const ChipInput: ChipInput;
+
+export declare interface ChipInputProps extends Omit<ContainerProps, 'defaultValue' | 'onChange'> {
+    /** ref to the input element */
+    inputRef?: React_2.MutableRefObject<HTMLInputElement | null>;
+    /** HTML input name */
+    inputName?: string;
+    /** Input Placeholder */
+    placeholder?: string;
+    /** ChipInput value */
+    value?: ChipItem[];
+    /** ChipInput default value */
+    defaultValue?: ChipItem[];
+    /** Callback to call when ChipInput's value changes */
+    onChange?: (items: ChipItem[]) => void;
+    /**
+     * Dropdown items.
+     * If disableOptions is true but options are provided, dropdown is still shown.
+     * To avoid dropdown to open at all, leave this prop empty
+     */
+    options?: Array<DropdownItem & {
+        value?: unknown;
+    }>;
+    /**
+     * Callback to call when Input typing occurs
+     * - returns the keyup event object with an additional textContent value
+     * - the event is debounced using the debounce function from lodash
+     */
+    onInputType?: (event: React_2.KeyboardEvent & {
+        textContent: string | null;
+    }) => void;
+    /** Debounce value in ms to which debounce the 'onInputType' callback */
+    onInputTypeDebounce?: number;
+    /** Callback called when a value is going to be added in the Chip Input, should return the configuration for the Chip */
+    onAdd?: (value: string | unknown) => ChipItem;
+    /** Set the current input text as a Chip when it loses focus */
+    confirmChipOnBlur?: boolean;
+    /**
+     * Set the current input text as a Chip when 'Space' is pressed
+     * @deprecated use separators prop instead
+     */
+    confirmChipOnSpace?: boolean;
+    /** ChipInput backgroundColor */
+    background?: keyof ThemeObj['palette'];
+    /** Chip generation triggers */
+    separators?: string[];
+    /** Show the error  */
+    hasError?: boolean;
+    /**
+     * Set the label for the error
+     * @deprecated use description instead
+     */
+    errorLabel?: string | undefined;
+    /** Background color for the error status */
+    errorBackgroundColor?: keyof ThemeObj['palette'];
+    /** Set the limit for chip inputs <br />
+     * <strong>Warning</strong>: be aware that this check is performed only on internal changes on items.
+     * If you change the value from outside, you are in charge of apply this check on the new value itself.
+     */
+    maxChips?: number | null;
+    /**
+     * Hide options to select values (on click).
+     * This prop does not prevent dropdown to open if options are
+     * provided. It only prevents it to open when clicking on the input.
+     * To avoid options to be shown at all, leave options empty
+     */
+    disableOptions?: boolean;
+    /** Icon on the right of the input */
+    icon?: keyof ThemeObj['icons'];
+    /** Action on Icon click */
+    iconAction?: React_2.ReactEventHandler;
+    /** Disable the icon */
+    iconDisabled?: boolean;
+    /** Icon color */
+    iconColor?: string | keyof ThemeObj['palette'];
+    /** select single replaceable value from options */
+    singleSelection?: boolean;
+    /** hide the input's bottom border */
+    hideBorder?: boolean;
+    /** disable the input (but not the dropdown, use disableOptions for this) */
+    disabled?: boolean;
+    /**
+     * Allow entering unique chips only <br />
+     * <strong>Warning</strong>: be aware that this check is performed only on internal changes on items.
+     * If you change the value from outside, you are in charge of apply this check on the new value itself.
+     */
+    requireUniqueChips?: boolean;
+    /** Input divider color */
+    bottomBorderColor?: DividerProps['color'];
+    /** Dropdown max height */
+    dropdownMaxHeight?: string;
+    /** Description for the input */
+    description?: string | undefined;
+    /** Custom Chip component */
+    ChipComponent?: React_2.ComponentType<ChipItem>;
+    /** allow to create chips from pasted values */
+    createChipOnPaste?: boolean;
+    /** Chip generation triggers on paste */
+    pasteSeparators?: string[];
+    /** Strategy on chips overflow */
+    wrap?: 'nowrap' | 'wrap';
+    /** maxHeight of Input in case of no horizontal scroll */
+    maxHeight?: string;
+}
+
+export declare type ChipItem = {
+    label?: string;
+} & ChipProps & {
+    value?: unknown;
+};
+
+export declare interface ChipProps extends RowProps {
+    /** Chip actions (buttons or icons) */
+    actions?: ChipAction[];
+    /** Chip Avatar Icon */
+    avatarIcon?: keyof ThemeObj['icons'];
+    /** Chip Avatar Background Color */
+    avatarBackground?: keyof ThemeObj['palette'];
+    /** Chip avatar color (icon color or capitals color) */
+    avatarColor?: keyof ThemeObj['palette'];
+    /** Chip avatar label. It allows to override the capitals for the avatar.
+     * If the main label is not a string, you have to fill this prop to show capitals in the avatar */
+    avatarLabel?: string;
+    /** Chip avatar picture */
+    avatarPicture?: string;
+    /** Chip background color */
+    background?: keyof ThemeObj['palette'];
+    /** Chip shape  */
+    shape?: 'regular' | 'round';
+    /** If an onClose callback is provided, this prop defines if the close action should be active or disabled */
+    closable?: boolean;
+    /** Chip text color */
+    color?: keyof ThemeObj['palette'];
+    /** Chip disabled status. If a string is provided it is shown in a tooltip */
+    disabled?: boolean | string;
+    /** Chip error. If a string is provided it is shown in a tooltip */
+    error?: boolean | string;
+    /** Define if the chip avatar is visible or hidden */
+    hasAvatar?: boolean;
+    /** Chip content key text */
+    keyLabel?: string;
+    /** Chip content text. It can be a simple string or a custom Component, which is then rendered inside a Row */
+    label?: string | React_2.ReactElement;
+    /** Chip max width */
+    maxWidth?: string;
+    /** Chip click callback */
+    onClick?: React_2.ReactEventHandler;
+    /** Callback to call when user tries to remove the Chip. If not provided, the close icon is hidden.
+     * Be aware that the close action can be also provided with the actions prop  */
+    onClose?: IconButtonProps['onClick'];
+    /** Chip double-click callback */
+    onDoubleClick?: React_2.ReactEventHandler;
+    /** Chip size */
+    size?: 'small' | 'medium' | 'large';
+    /** Tooltip placement */
+    tooltipPlacement?: React_2.ComponentPropsWithoutRef<typeof Tooltip>['placement'];
+}
+
+export declare type CloseModalFn = () => void;
+
+export declare const Collapse: React_2.ForwardRefExoticComponent<CollapseProps & React_2.RefAttributes<HTMLElement>>;
+
+export declare interface CollapseProps extends HTMLAttributes<HTMLDivElement> {
+    /** Orientation of the collapsing action */
+    orientation?: 'vertical' | 'horizontal';
+    /** control prop */
+    open: boolean;
+    /** Size of the collapse element on the opposite axis
+     * (e.g. height if the collapse orientation is horizontal) */
+    crossSize?: string;
+    /** Disable the transition */
+    disableTransition?: boolean;
+    /** Content */
+    children: React_2.ReactNode | React_2.ReactNode[];
+}
+
+export declare const Collapser: React_2.ForwardRefExoticComponent<CollapserProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface CollapserProps {
+    clickCallback: React_2.ReactEventHandler;
+}
+
+export declare const CollapsingActions: React_2.ForwardRefExoticComponent<CollapsingActionsProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface CollapsingActionsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Actions to show
+     * <br />
+     * <code>type Action = { type?: never; iconType?: IconButtonProps['type'] } & IconButtonProps & DropdownItem;</code>
+     */
+    actions: Action[];
+    /** Size for all the icon buttons. Can be overwritten by the single action prop */
+    size?: IconButtonProps['size'];
+    /** Max number of actions to show when there is plenty of space */
+    maxVisible?: number;
+    /** Alignment of the actions inside the container */
+    alignment?: 'start' | 'end';
+}
+
+export declare const Container: React_2.ForwardRefExoticComponent<ContainerProps & React_2.RefAttributes<HTMLDivElement>>;
+
+declare interface ContainerElProps {
+    /** The Container orientation (css flex-direction prop or 'vertical' or 'horizontal') */
+    orientation?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    /** Type of the Container's corners */
+    borderRadius?: 'regular' | 'round' | 'half' | 'none';
+    borderColor?: string | keyof ThemeObj['palette'];
+    /** Container background color */
+    background?: string | keyof ThemeObj['palette'];
+    /** Container height: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    height?: 'fit' | 'fill' | CSSStyleDeclaration['height'] | number;
+    /** Container minHeight: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    minHeight?: 'fit' | 'fill' | CSSStyleDeclaration['minHeight'] | number;
+    /** Container maxHeight: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    maxHeight?: 'fit' | 'fill' | CSSStyleDeclaration['maxHeight'] | number;
+    /** Container width: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    width?: 'fit' | 'fill' | CSSStyleDeclaration['width'] | number;
+    /** Container minWidth: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    minWidth?: 'fit' | 'fill' | CSSStyleDeclaration['minWidth'] | number;
+    /** Container maxWidth: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    maxWidth?: 'fit' | 'fill' | CSSStyleDeclaration['maxWidth'] | number;
+    /** Container flex alignment along the main axis */
+    mainAlignment?: 'stretch' | 'center' | 'baseline' | 'flex-start' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly' | 'unset';
+    /** Container flex alignment along the cross axis */
+    crossAlignment?: 'stretch' | 'center' | 'baseline' | 'flex-start' | 'flex-end' | 'unset';
+    /** Whether the Container items should wrap or not */
+    wrap?: 'wrap' | 'nowrap' | 'wrap-reverse' | 'unset';
+    /** an object specifying the Container padding */
+    padding?: PaddingObj | string | 0;
+    /** Gap flex css property */
+    gap?: string;
+    /** Flex grow css property */
+    flexGrow?: string | number;
+    /** Flex shrink css property */
+    flexShrink?: string | number;
+    /** Flex basis css property */
+    flexBasis?: string;
+    /** Margin css property */
+    margin?: {
+        left?: string;
+        right?: string;
+    };
+}
+
+export declare interface ContainerProps extends Omit<ContainerElProps, 'orientation'>, Omit<HTMLAttributes<HTMLDivElement>, keyof ContainerElProps> {
+    orientation?: 'vertical' | 'horizontal' | ContainerElProps['orientation'];
+    children?: React_2.ReactNode | React_2.ReactNode[];
+}
+
+export declare type CreateModalArgs = [modalProps: ModalProps, customModal?: false] | [customModalProps: CustomModalProps, customModal: true];
+
+export declare type CreateModalFn = (...args: CreateModalArgs) => CloseModalFn;
+
+export declare type CreateSnackbarFn = (props: SnackbarProps & {
+    key?: string;
+    replace?: boolean;
+}) => void;
+
+export declare type Crumb = DropdownItem & HTMLAttributes<HTMLDivElement>;
+
+declare type CSSObject = {
+    [K in keyof CSSProperties]: CSSProperties[K] | (() => NonNullable<CSSProperties[K]>);
+};
+
+export declare const CustomModal: React_2.ForwardRefExoticComponent<Pick<ModalProps, "open" | "background" | "maxHeight" | "zIndex" | "children" | "size" | "disablePortal" | "onClose"> & Omit<React_2.HTMLAttributes<HTMLDivElement>, keyof ModalProps> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare type CustomModalProps = Pick<ModalProps, 'background' | 'size' | 'open' | 'onClose' | 'zIndex' | 'maxHeight' | 'disablePortal' | 'children'> & Omit<HTMLAttributes<HTMLDivElement>, keyof ModalProps>;
+
+export declare const DateTimePicker: React_2.ForwardRefExoticComponent<DateTimePickerProps & React_2.RefAttributes<DatePicker<never, undefined>>>;
+
+export declare interface DateTimePickerProps extends Omit<ReactDatePickerProps, 'onChange'> {
+    /** Input's background color */
+    backgroundColor?: keyof ThemeObj['palette'];
+    /** Close icon to clear the Input */
+    isClearable?: boolean;
+    /** Label for input */
+    label: string;
+    /** input change callback */
+    onChange?: (newValue: Date | null) => void;
+    /** default value of the input */
+    defaultValue?: Date;
+    /** Whether the input has an error */
+    hasError?: boolean;
+    /** Error Message */
+    errorLabel?: string;
+    /** Show time picker   */
+    includeTime?: boolean;
+    /** Date format  */
+    dateFormat?: string;
+    /** Time format  */
+    timeFormat?: string;
+    /** Label for time options */
+    timeLabel?: string;
+    /** Minutes Gap between different time options */
+    timeIntervals?: number;
+    /** Use Chips to show selected value */
+    enableChips?: boolean;
+    /** Pass chip props */
+    chipProps?: Partial<ChipProps>;
+    /** Picker width: <br/>
+     *  	`fit`: shorthand for fit-content
+     *  	`fill`: semantic alternative for `100%`
+     *  	number: measure in px
+     *  	string: any measure in CSS syntax
+     */
+    width?: 'fit' | 'fill' | string | number;
+    /** Use Custom Component to trigger the picker */
+    CustomComponent?: React_2.ComponentType<{
+        value?: string | undefined;
+        onClick?: React_2.ReactEventHandler;
+    }>;
+    /** Disable the input */
+    disabled?: boolean;
+}
+
+export declare const DefaultTabBarItem: React_2.ForwardRefExoticComponent<DefaultTabBarItemProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface DefaultTabBarItemProps extends ContainerProps {
+    item: Item;
+    selected: boolean;
+    background: string | keyof ThemeObj['palette'];
+    onClick: React_2.ReactEventHandler;
+    underlineColor: string | keyof ThemeObj['palette'];
+    forceWidthEquallyDistributed: boolean;
+}
+
+export declare const Divider: React_2.ForwardRefExoticComponent<Partial<DividerProps> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Divider color */
+    color: string | keyof ThemeObj['palette'];
+}
+
+export declare const Drag: React_2.ForwardRefExoticComponent<DragProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare type DragObj = {
+    event: React_2.DragEvent;
+    data?: Record<string, unknown>;
+    type?: string;
+};
+
+export declare interface DragProps {
+    /** Callback for on onDragStart */
+    onDragStart?: React_2.DragEventHandler;
+    /** Callback for on onDragStart */
+    onDragEnd?: React_2.DragEventHandler;
+    /** type to assign to data */
+    type?: string;
+    /** data assigned to the drag event */
+    data?: Record<string, unknown>;
+    /** style applied to drag container */
+    style?: HTMLAttributes<HTMLDivElement>['style'];
+    /** whether element should be draggable or not */
+    dragDisabled?: boolean;
+    /** Content to drag */
+    children: React_2.ReactNode | React_2.ReactNode[];
+}
+
+export declare const Drop: React_2.ForwardRefExoticComponent<DropProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const Dropdown: React_2.ForwardRefExoticComponent<DropdownProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface DropdownItem {
+    type?: 'divider';
+    id: string;
+    label: string;
+    icon?: string;
+    click?: (e: React_2.SyntheticEvent<HTMLElement> | KeyboardEvent) => void;
+    selected?: boolean;
+    customComponent?: React_2.ReactNode;
+    disabled?: boolean;
+    items?: Array<DropdownItem>;
+    keepOpen?: boolean;
+}
+
+export declare interface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'contextMenu'> {
+    /** Whether to disable the Dropdown or not */
+    disabled?: boolean;
+    /** Array of items to display */
+    items: Array<DropdownItem>;
+    /** Css display property */
+    display?: 'block' | 'inline-block';
+    /** Dropdown width type */
+    width?: string;
+    /** Css max-width property */
+    maxWidth?: string;
+    /** Css max-height property */
+    maxHeight?: string;
+    /** whether to manage the keyboard events for dropdown trigger */
+    handleTriggerEvents?: boolean;
+    /** whether to disable the re-focus of trigger */
+    disableRestoreFocus?: boolean;
+    /** whether to focus the first item of the Dropdown on open */
+    disableAutoFocus?: boolean;
+    /** whether user can select multiple items of dropdown aka do not close popover on item click */
+    multiple?: boolean;
+    /** Open dropdown on right click at cursor position */
+    contextMenu?: boolean;
+    /** Callback for opened Dropdown */
+    onOpen?: () => void;
+    /** Callback for closed Dropdown */
+    onClose?: () => void;
+    /** Only one component can be passed as children */
+    children: React_2.ReactElement;
+    /** trigger ref that can be used instead of lost children ref caused by cloneElement */
+    triggerRef?: React_2.Ref<HTMLElement>;
+    /** Placement of the dropdown */
+    placement?: 'auto' | 'auto-start' | 'auto-end' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end';
+    /** Flag to disable the Portal implementation */
+    disablePortal?: boolean;
+    /** Whether the Component is visible or not */
+    forceOpen?: boolean;
+    /** Whether to preventDefault on Dropdown click */
+    preventDefault?: boolean;
+    /** Customize selected background color */
+    selectedBackgroundColor?: keyof ThemeObj['palette'];
+    /** Item Icon size */
+    itemIconSize?: React_2.ComponentPropsWithRef<typeof Icon>['size'];
+    /** Item Text size */
+    itemTextSize?: React_2.ComponentPropsWithRef<typeof Text_2>['size'];
+    /** Item Padding Between */
+    itemPaddingBetween?: keyof ThemeObj['sizes']['padding'];
+    /** Ref assign to the dropdown list popper container */
+    dropdownListRef?: React_2.RefObject<HTMLDivElement>;
+}
+
+export declare interface DropProps {
+    /** Callback for on drop */
+    onDrop?: (dragObj: DragObj) => void;
+    /** Callback for on onDragEnter */
+    onDragEnter?: (dragObj: DragObj) => {
+        success: boolean;
+    } | undefined;
+    /** acceptType should be an array which accept base on dragged type */
+    acceptType?: string[];
+    /** Style object for drag accept */
+    acceptStyle?: StyleObj;
+    /** Style object for drag reject */
+    rejectStyle?: StyleObj;
+    /** Overlay component for drag accept */
+    overlayAcceptComponent: React_2.ReactNode;
+    /** Overlay component for drag Deny */
+    overlayDenyComponent: React_2.ReactNode;
+    /** Content where activate drop */
+    children: React_2.ReactNode | React_2.ReactNode[];
+}
+
+export declare interface DSWindow {
+    draggedItem?: {
+        event: React_2.DragEvent<HTMLDivElement>;
+        data: Record<string, unknown>;
+        type: string;
+    };
+}
+
+declare type ElementType = 'listItem' | 'button' | 'list' | 'chipInputKeys' | 'chipInputSpace';
+
+export declare const EmailComposerInput: React_2.ForwardRefExoticComponent<EmailComposerInputProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare interface EmailComposerInputProps extends HTMLAttributes<HTMLDivElement> {
+    /** Input's Placeholder */
+    placeholder?: string;
+    /** Placeholder Type */
+    placeholderType?: 'default' | 'inline';
+    /** Input's value */
+    value?: string;
+    /** Callback to call when Input's value changes */
+    onChange?: (ev: React_2.ChangeEvent<HTMLInputElement>) => void;
+}
+
+export declare const FileLoader: React_2.ForwardRefExoticComponent<FileLoaderProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+export declare type FileLoaderProps = IconButtonProps & {
+    onChange?: (event: React_2.ChangeEvent<HTMLInputElement>, files: FileList | null) => void;
+    /** icon name */
+    icon?: IconButtonProps['icon'];
+    /** accept multiple files */
+    multiple?: boolean;
+    /** capture mode (see <input type="file"> docs) */
+    capture?: string;
+    /** Accept attribute of input element */
+    accept?: string;
+};
+
+export declare interface FormElementProps extends ContainerProps {
+    label?: TextProps['children'];
+    children?: React_2.ReactNode | React_2.ReactNode[];
+}
+
+export declare const FormRow: React_2.ForwardRefExoticComponent<FormElementProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const FormSection: React_2.ForwardRefExoticComponent<FormElementProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const FormSubSection: React_2.ForwardRefExoticComponent<FormElementProps & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare const generateColorSet: ({ regular, hover, active, disabled, focus }: Pick<ThemeColorObj, 'regular'> & Partial<Omit<ThemeColorObj, 'regular'>>, dark?: boolean) => ThemeColorObj;
+
+/**
+ * Create a function to retrieve the color of the given name based on the theme palette if the name is a palette key,
+ * generating a set with the colorSet utility if the color is not a palette key.
+ * Useful for calling inside styledComponents in a short mode
+ * @param {string} color It can contain also the variant in the form color[.variant]
+ * @example
+ * getColor('primary.disabled');
+ *
+ * // from styled components
+ * const StyledComponent = styled.div`
+ * 		background-color: ${getColor('secondary')}
+ * `
+ * @returns {({theme?: Theme}) => string} a function that, given the theme, returns the wanted color
+     */
+ export declare function getColor(color: string): (args: {
+     theme: ThemeObj;
+ }) => string;
+
+ /**
+  * Retrieve the color of the given name based on the theme palette if the name is a palette key,
+  * generating a set with the colorSet utility if the color is not a palette key
+  * @param {string} color - It can contain also the variant in the form color[.variant]
+  * @param {ThemeObj} theme - The theme object
+  * @example
+  * const theme = useTheme();
+  * getColor('gray5', theme);
+  *
+  * // from styled components
+  * const StyledComponent = styled.div`
+  * 		background-color: ${({ theme }) => getColor('secondary', theme)}
+  * `
+  * @returns {string} The wanted color
+  */
+ export declare function getColor(color: string, theme: ThemeObj): string;
+
+ export declare function getKeyboardPreset(type: ElementType, callback: (e: KeyboardEvent) => void, ref?: React_2.MutableRefObject<HTMLElement | null> | undefined, keys?: string[], modifier?: boolean): KeyboardPreset;
+
+ declare function getPadding(padding: PaddingStringComposition | PaddingObj): (args: {
+     theme: ThemeObj;
+ }) => string;
+
+ declare function getPadding(padding: PaddingStringComposition | PaddingObj, theme: ThemeObj): string;
+
+ declare function getPadding(padding: PaddingStringComposition | PaddingObj, theme?: ThemeObj): string | ((args: {
+     theme: ThemeObj;
+ }) => string);
+ export { getPadding }
+ export { getPadding as parsePadding }
+
+ declare type HtmlElementKeyboardEventKey = {
+     [K in keyof HTMLElementEventMap]: HTMLElementEventMap[K] extends KeyboardEvent ? K : never;
+ }[keyof HTMLElementEventMap];
+
+ export declare const Icon: StyledComponent<React_2.ForwardRefExoticComponent<IconComponentProps & React_2.RefAttributes<SVGSVGElement>>, DefaultTheme, Required<Pick<IconProps, "color" | "size">> & IconProps & React_2.SVGAttributes<SVGSVGElement>, "color" | "size">;
+
+ export declare const IconButton: React_2.ForwardRefExoticComponent<IconButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+
+ export declare type IconButtonProps = ButtonProps & {
+     /** Color of the icon */
+     iconColor?: string | keyof ThemeObj['palette'];
+     /** Color of the button */
+     backgroundColor?: string | keyof ThemeObj['palette'];
+     /** whether to disable the IconButton or not */
+     disabled?: boolean;
+     /** button size */
+     size?: ButtonProps['size'];
+     /** Custom button size */
+     customSize?: {
+         iconSize: string | keyof ThemeObj['sizes']['icon'];
+         paddingSize: 0 | string | keyof ThemeObj['sizes']['padding'];
+     };
+     /** icon name */
+     icon: keyof ThemeObj['icons'];
+     /** IconButton border radius */
+     borderRadius?: 'regular' | 'round';
+     /** Click callback */
+     onClick: (e: KeyboardEvent | React_2.MouseEvent<HTMLButtonElement>) => void;
+     /**
+      * Custom icon color
+      * @deprecated use iconColor instead
+      */
+     customIconColor?: string;
+     secondaryAction?: never;
+ };
+
+ export declare const IconCheckbox: React_2.ForwardRefExoticComponent<IconCheckboxProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface IconCheckboxProps extends Omit<ContainerProps, 'margin'> {
+     /** Status of the IconCheckbox */
+     defaultChecked?: boolean;
+     /** IconCheckbox text */
+     label?: string;
+     /** IconCheckbox radius */
+     borderRadius?: 'regular' | 'round';
+     /** whether to disable the IconCheckbox or not */
+     disabled?: boolean;
+     /** IconCheckbox icon */
+     icon: keyof ThemeObj['icons'];
+     /** IconCheckbox size */
+     size?: 'small' | 'regular' | 'large';
+     /** IconCheckbox margin */
+     margin?: keyof ThemeObj['sizes']['padding'];
+     /** IconCheckbox value */
+     value?: boolean;
+     /** change callback */
+     onChange: () => void;
+ }
+
+ declare type IconComponent = React_2.ComponentType<React_2.SVGProps<SVGSVGElement> & {
+     ref: React_2.ForwardedRef<SVGSVGElement>;
+ }>;
+
+ export declare interface IconComponentProps extends SVGAttributes<SVGSVGElement> {
+     /** Icon to show. It can be a string key for the theme icons or a custom icon component */
+     icon: keyof ThemeObj['icons'] | IconComponent;
+     /** whether the icon is in a disabled element */
+     disabled?: boolean;
+     /** action to perform on Icon Click
+      * @deprecated consider using an IconButton instead of an Icon
+      */
+     onClick?: React_2.ReactEventHandler<SVGSVGElement>;
+ }
+
+ export declare interface IconProps extends IconComponentProps {
+     /** Icon Color */
+     color?: string | keyof ThemeObj['palette'];
+     /** Custom color, css syntax
+      * @deprecated use color instead
+      */
+     customColor?: string;
+     /** Icon size */
+     size?: keyof ThemeObj['sizes']['icon'];
+ }
+
+ declare type IconSkeletonProps = {
+     variant?: string;
+     backgroundSize?: string;
+     size?: keyof typeof SIZES;
+     width?: string;
+ };
+
+ export declare type Input = React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<HTMLDivElement>> & {
+     _newId?: number;
+ };
+
+ export declare const Input: Input;
+
+ export declare interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+     /** Input's background color */
+     backgroundColor?: keyof ThemeObj['palette'];
+     /** whether to disable the Input or not */
+     disabled?: boolean;
+     /** Input's text color */
+     textColor?: keyof ThemeObj['palette'];
+     /** Input's bottom border color */
+     borderColor?: keyof ThemeObj['palette'];
+     /** Label of the input, will act (graphically) as placeholder when the input is not focused */
+     label?: string;
+     /** input change callback */
+     onChange?: (e: React_2.ChangeEvent<HTMLInputElement>) => void;
+     /** ref to the input element */
+     inputRef?: React_2.RefObject<HTMLInputElement>;
+     /** value of the input */
+     value?: string | number;
+     /** default value of the input */
+     defaultValue?: string | number;
+     /** Whether the input has an error */
+     hasError?: boolean;
+     /** Whether the input should focus on load */
+     autoFocus?: boolean;
+     /** input autocompletion type (HTML input attribute) */
+     autoComplete?: string;
+     /** HTML input name */
+     inputName?: string;
+     /** Custom component to show on the right of the input, it occupies 56x42 px */
+     CustomIcon?: React_2.ComponentType<{
+         hasError: boolean;
+         hasFocus: boolean;
+         disabled: boolean;
+     }>;
+     /** input type attribute */
+     type?: string;
+     /** hide the inputs bottom line */
+     hideBorder?: boolean;
+     /** on Enter key callback */
+     onEnter?: (e: KeyboardEvent) => void;
+     /** Description of the input */
+     description?: string | undefined;
+ }
+
+ export declare function isThemeColor(color: string, theme: ThemeObj): color is ThemePaletteColorKey;
+
+ export declare function isThemeSize(size: string, sizeObj: ThemeSizeObj): size is keyof ThemeSizeObj;
+
+ declare interface Item {
+     id: string;
+     label: string | React_2.ReactElement;
+     CustomComponent?: React_2.ComponentType<DefaultTabBarItemProps & HTMLAttributes<HTMLDivElement>>;
+     disabled?: boolean;
+ }
+
+ export declare interface ItemComponentProps<T extends ItemType> {
+     item: T;
+     visible: boolean;
+     active: boolean;
+     selected: boolean;
+     background: keyof ThemeObj['palette'];
+     selectedBackground: keyof ThemeObj['palette'];
+     activeBackground: keyof ThemeObj['palette'];
+ }
+
+ export declare interface ItemType {
+     id: string;
+ }
+
+ export declare type KeyboardPreset = Array<KeyboardPresetObj>;
+
+ declare type KeyboardPresetObj = {
+     type: HtmlElementKeyboardEventKey;
+     callback: (e: KeyboardEvent) => void;
+     keys: string[];
+     modifier?: boolean;
+     haveToPreventDefault?: boolean;
+ };
+
+ export declare interface LabelFactoryProps {
+     label: string | undefined;
+     open: boolean;
+     focus: boolean;
+     background: string | keyof ThemeObj['palette'];
+     multiple: boolean;
+     disabled: boolean;
+     selected: SelectItem[];
+ }
+
+ export declare const Link: React_2.ForwardRefExoticComponent<{
+     /** Whether the link should be underlined */
+     underlined?: boolean | undefined;
+ } & React_2.AnchorHTMLAttributes<HTMLAnchorElement> & TextProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare type LinkProps = {
+     /** Whether the link should be underlined */
+     underlined?: boolean;
+ } & React_2.AnchorHTMLAttributes<HTMLAnchorElement> & TextProps;
+
+ export declare const List: React_2.ForwardRefExoticComponent<ListProps<any> & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface ListProps<T extends ItemType> extends ContainerProps {
+     /** Array of items to be displayed */
+     items: Array<T>;
+     /** props to be passed down to each item */
+     itemProps?: Record<string, unknown>;
+     /** Component to be rendered for each item */
+     ItemComponent: React_2.ComponentType<ItemComponentProps<T>>;
+     /** object whose keys are the indexes of the selected items */
+     selected?: Record<string, unknown>;
+     /** id of the active item */
+     active?: string;
+     /** callback to be executed when the bottom element is rendered */
+     onListBottom?: () => void;
+     /** List background color */
+     background?: keyof ThemeObj['palette'];
+     /** Selected list item background color */
+     selectedBackground?: keyof ThemeObj['palette'];
+     /** Active List item background color */
+     activeBackground?: keyof ThemeObj['palette'];
+     /** Disable keyboard shortcuts */
+     keyboardShortcutsIsDisabled?: boolean;
+ }
+
+ export declare const LoadMore: React_2.ForwardRefExoticComponent<LoadMoreProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface LoadMoreProps extends ContainerProps {
+     label?: TextProps['children'];
+ }
+
+ declare type LogoSkeletonProps = {
+     variant?: string;
+     backgroundSize?: string;
+     radius?: string;
+     size?: keyof typeof SIZES;
+     width?: string;
+     height?: string;
+ };
+
+ export declare const Modal: React_2.ForwardRefExoticComponent<ModalProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare function ModalManager({ children }: ModalManagerProps): JSX.Element;
+
+ export declare const ModalManagerContext: React_2.Context<CreateModalFn>;
+
+ export declare interface ModalManagerProps {
+     children: React_2.ReactNode | React_2.ReactNode[];
+ }
+
+ export declare interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+     /** Modal background */
+     background?: string | keyof ThemeObj['palette'];
+     /** Modal type */
+     type?: 'default' | 'error';
+     /** Modal title */
+     title?: string | React_2.ReactElement;
+     /** Modal size */
+     size?: 'extrasmall' | 'small' | 'medium' | 'large';
+     /** Boolean to show the modal */
+     open?: boolean;
+     /** Centered Modal */
+     centered?: boolean;
+     /** Callback for main action */
+     onConfirm?: (event: React_2.MouseEvent<HTMLButtonElement> | KeyboardEvent) => void;
+     /** Label for the Main action Button */
+     confirmLabel?: string;
+     /** BackgroundColor for the Main action Button */
+     confirmColor?: string | keyof ThemeObj['palette'];
+     /** Callback for secondary action */
+     onSecondaryAction?: (event: React_2.MouseEvent<HTMLButtonElement> | KeyboardEvent) => void;
+     /** Label for the Secondary action Button */
+     secondaryActionLabel?: string;
+     /** Callback to close the Modal */
+     onClose?: (event: React_2.MouseEvent | KeyboardEvent) => void;
+     /** Label for the Modal close Button */
+     dismissLabel?: string;
+     /** Label for copy button in the Error Modal */
+     copyLabel?: string;
+     /** Optional element to show in the footer of the Modal */
+     optionalFooter?: React_2.ReactElement;
+     /** Prop to override the default footer buttons */
+     customFooter?: React_2.ReactElement;
+     /** Hide the footer completely */
+     hideFooter?: boolean;
+     /** Show icon to close Modal */
+     showCloseIcon?: boolean;
+     /** Css property to handle the stack order of multiple modals */
+     zIndex?: number;
+     /** max height of the modal body */
+     maxHeight?: string;
+     /** Flag to disable the Portal implementation */
+     disablePortal?: boolean;
+     /** Content of the modal */
+     children?: React_2.ReactNode | React_2.ReactNode[];
+ }
+
+ export declare const MultiButton: React_2.ForwardRefExoticComponent<{
+     /** MultiButton text */
+     label?: string | undefined;
+     /** whether to disable the Primary Button or not */
+     disabledPrimary?: boolean | undefined;
+     /** whether to disable the Secondary Dropdown or not */
+     disabledSecondary?: boolean | undefined;
+     /** MultiButton icon */
+     icon?: string | undefined;
+     /** Main icon */
+     primaryIcon?: string | undefined;
+     /** Color of the Button label */
+     color?: string | undefined;
+     /** Color of the Button background */
+     background?: string | undefined;
+     /** Dropdown items */
+     items: DropdownProps['items'];
+     /** Button size */
+     size?: "medium" | "large" | "extralarge" | undefined;
+     /** Dropdown properties */
+     dropdownProps?: DropdownProps | undefined;
+ } & Omit<ButtonProps, "disabled" | "icon" | "secondaryAction"> & React_2.RefAttributes<HTMLButtonElement>>;
+
+ export declare type MultiButtonProps = {
+     /** MultiButton text */
+     label?: string;
+     /** whether to disable the Primary Button or not */
+     disabledPrimary?: boolean;
+     /** whether to disable the Secondary Dropdown or not */
+     disabledSecondary?: boolean;
+     /** MultiButton icon */
+     icon?: keyof ThemeObj['icons'];
+     /** Main icon */
+     primaryIcon?: keyof ThemeObj['icons'];
+     /** Color of the Button label */
+     color?: string;
+     /** Color of the Button background */
+     background?: string;
+     /** Dropdown items */
+     items: DropdownProps['items'];
+     /** Button size */
+     size?: Extract<ButtonProps['size'], 'medium' | 'large' | 'extralarge'>;
+     /** Dropdown properties */
+     dropdownProps?: DropdownProps;
+ } & Omit<ButtonProps, 'secondaryAction' | 'icon' | 'disabled'>;
+
+ declare type Options = {
+     removeFrom: 'end' | 'start';
+     maxVisible?: number;
+ };
+
+ export declare const Padding: React_2.ForwardRefExoticComponent<(PaddingProps & Omit<React_2.HTMLAttributes<HTMLDivElement>, "id" | "height" | "width" | "color" | "translate" | "hidden" | "dir" | "slot" | "style" | "title" | "accessKey" | "draggable" | "lang" | "className" | "prefix" | "children" | "contentEditable" | "inputMode" | "tabIndex" | "defaultChecked" | "defaultValue" | "suppressContentEditableWarning" | "suppressHydrationWarning" | "contextMenu" | "placeholder" | "spellCheck" | "radioGroup" | "role" | "about" | "datatype" | "inlist" | "property" | "resource" | "typeof" | "vocab" | "autoCapitalize" | "autoCorrect" | "autoSave" | "itemProp" | "itemScope" | "itemType" | "itemID" | "itemRef" | "results" | "security" | "unselectable" | "is" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-details" | "aria-disabled" | "aria-dropeffect" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-grabbed" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "dangerouslySetInnerHTML" | "onCopy" | "onCopyCapture" | "onCut" | "onCutCapture" | "onPaste" | "onPasteCapture" | "onCompositionEnd" | "onCompositionEndCapture" | "onCompositionStart" | "onCompositionStartCapture" | "onCompositionUpdate" | "onCompositionUpdateCapture" | "onFocus" | "onFocusCapture" | "onBlur" | "onBlurCapture" | "onChange" | "onChangeCapture" | "onBeforeInput" | "onBeforeInputCapture" | "onInput" | "onInputCapture" | "onReset" | "onResetCapture" | "onSubmit" | "onSubmitCapture" | "onInvalid" | "onInvalidCapture" | "onLoad" | "onLoadCapture" | "onError" | "onErrorCapture" | "onKeyDown" | "onKeyDownCapture" | "onKeyPress" | "onKeyPressCapture" | "onKeyUp" | "onKeyUpCapture" | "onAbort" | "onAbortCapture" | "onCanPlay" | "onCanPlayCapture" | "onCanPlayThrough" | "onCanPlayThroughCapture" | "onDurationChange" | "onDurationChangeCapture" | "onEmptied" | "onEmptiedCapture" | "onEncrypted" | "onEncryptedCapture" | "onEnded" | "onEndedCapture" | "onLoadedData" | "onLoadedDataCapture" | "onLoadedMetadata" | "onLoadedMetadataCapture" | "onLoadStart" | "onLoadStartCapture" | "onPause" | "onPauseCapture" | "onPlay" | "onPlayCapture" | "onPlaying" | "onPlayingCapture" | "onProgress" | "onProgressCapture" | "onRateChange" | "onRateChangeCapture" | "onSeeked" | "onSeekedCapture" | "onSeeking" | "onSeekingCapture" | "onStalled" | "onStalledCapture" | "onSuspend" | "onSuspendCapture" | "onTimeUpdate" | "onTimeUpdateCapture" | "onVolumeChange" | "onVolumeChangeCapture" | "onWaiting" | "onWaitingCapture" | "onAuxClick" | "onAuxClickCapture" | "onClick" | "onClickCapture" | "onContextMenu" | "onContextMenuCapture" | "onDoubleClick" | "onDoubleClickCapture" | "onDrag" | "onDragCapture" | "onDragEnd" | "onDragEndCapture" | "onDragEnter" | "onDragEnterCapture" | "onDragExit" | "onDragExitCapture" | "onDragLeave" | "onDragLeaveCapture" | "onDragOver" | "onDragOverCapture" | "onDragStart" | "onDragStartCapture" | "onDrop" | "onDropCapture" | "onMouseDown" | "onMouseDownCapture" | "onMouseEnter" | "onMouseLeave" | "onMouseMove" | "onMouseMoveCapture" | "onMouseOut" | "onMouseOutCapture" | "onMouseOver" | "onMouseOverCapture" | "onMouseUp" | "onMouseUpCapture" | "onSelect" | "onSelectCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onScroll" | "onScrollCapture" | "onWheel" | "onWheelCapture" | "onAnimationStart" | "onAnimationStartCapture" | "onAnimationEnd" | "onAnimationEndCapture" | "onAnimationIteration" | "onAnimationIterationCapture" | "onTransitionEnd" | "onTransitionEndCapture">) & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare type PaddingObj = {
+     value: string | keyof ThemeObj['sizes']['padding'] | 0;
+ } | {
+     all: string | keyof ThemeObj['sizes']['padding'] | 0;
+ } | RequireAtLeastOne<{
+     vertical: string | keyof ThemeObj['sizes']['padding'] | 0;
+     horizontal: string | keyof ThemeObj['sizes']['padding'] | 0;
+ }> | RequireAtLeastOne<{
+     top: string | keyof ThemeObj['sizes']['padding'] | 0;
+     right: string | keyof ThemeObj['sizes']['padding'] | 0;
+     bottom: string | keyof ThemeObj['sizes']['padding'] | 0;
+     left: string | keyof ThemeObj['sizes']['padding'] | 0;
+ }>;
+
+ export declare type PaddingProps = {
+     width?: string;
+     height?: string;
+     children?: React_2.ReactNode | React_2.ReactNode[];
+ } & PaddingObj & HTMLAttributes<HTMLDivElement>;
+
+ declare type PaddingString = `${string | keyof ThemeObj['sizes']['padding']}`;
+
+ declare type PaddingStringComposition = PaddingString | `${PaddingString} | ${PaddingString}` | `${PaddingString} ${PaddingString} ${PaddingString}` | `${PaddingString} ${PaddingString} ${PaddingString} ${PaddingString}`;
+
+ export declare const Paragraph: React_2.ForwardRefExoticComponent<TextProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare type ParagraphProps = TextProps;
+
+ export declare const PasswordInput: React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare const Popover: React_2.ForwardRefExoticComponent<PopoverProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface PopoverProps extends PopperProps {
+     /** Whether to activate the popover on hover of anchorEl. If true, the 'open' prop will be ignored.  */
+     activateOnHover?: boolean;
+     /** Whether to style the popover container as a modal component */
+     styleAsModal?: boolean;
+ }
+
+ export declare const Popper: React_2.ForwardRefExoticComponent<PopperProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface PopperProps extends HTMLAttributes<HTMLDivElement> {
+     /** Whether the popper is open or not */
+     open?: boolean;
+     /** Ref to the DOM element triggering the popper */
+     anchorEl: React_2.RefObject<HTMLElement>;
+     /** Optional parameter to anchor the popper to a virtual element, defined by his x, y coordinates (ex. {x: 2, y: 2}) */
+     virtualElement?: {
+         x: number;
+         y: number;
+     };
+     /** Whether to disable the re-focus of Popper trigger */
+     disableRestoreFocus?: boolean;
+     /** Popper placement relative to the anchorEl */
+     placement?: Placement_2;
+     /** Callback for closed Popper */
+     onClose: () => void;
+     /** Flag to disable the Portal implementation */
+     disablePortal?: boolean;
+     /** Popper content */
+     children: React_2.ReactNode | React_2.ReactNode[];
+ }
+
+ export declare const Portal: React_2.ForwardRefExoticComponent<PortalProps & React_2.RefAttributes<React_2.ReactPortal>>;
+
+ export declare interface PortalProps {
+     /** The children to render into the `container` */
+     children: React_2.ReactElement;
+     /**
+      * HTML node where to insert the Portal's children.
+      * The default value is 'windowObj.document'.
+      * */
+     container?: Element;
+     /** Flag to show or hide Portal's content */
+     show?: boolean;
+     /** Flag to disable the Portal implementation */
+     disablePortal?: boolean;
+ }
+
+ export declare function pseudoClasses(theme: ThemeObj, color: string | keyof ThemeObj['palette'], cssProperty?: string): FlattenSimpleInterpolation;
+
+ export declare const Quota: React_2.ForwardRefExoticComponent<QuotaProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface QuotaProps extends ContainerProps {
+     /** Quota background color */
+     background?: keyof ThemeObj['palette'];
+     /** Quota percentage */
+     fill: number;
+     /** Quota fill background color */
+     fillBackground?: keyof ThemeObj['palette'];
+     /** Quota height */
+     height?: number | string;
+ }
+
+ export declare const Radio: React_2.ForwardRefExoticComponent<RadioProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare const RadioGroup: React_2.ForwardRefExoticComponent<RadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface RadioGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+     /** Default value for the radio group */
+     defaultValue?: string;
+     /** Radio group value */
+     value?: string;
+     /** change callback */
+     onChange?: (value: string) => void;
+     /** children elements of Radio Group */
+     children: JSX.Element[];
+ }
+
+ export declare interface RadioProps extends Omit<ContainerProps, 'onChange'> {
+     /** status of the Radio */
+     defaultChecked?: boolean;
+     /** Radio checked */
+     checked?: boolean;
+     /** value of the Radio */
+     value?: string;
+     /** Radio text */
+     label?: string | React_2.ReactElement;
+     /** whether to disable the radio or not */
+     disabled?: boolean;
+     /** click callback */
+     onClick?: React_2.ReactEventHandler;
+     /** change callback */
+     onChange?: (checked: boolean) => void;
+     /** radio padding */
+     padding?: ContainerProps['padding'];
+     /** available sizes */
+     size?: RadioSize;
+     /** icon color */
+     iconColor?: keyof ThemeObj['palette'];
+ }
+
+ declare type RadioSize = 'medium' | 'small';
+
+ declare type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+     [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+ }[Keys];
+
+ export declare function Responsive({ children, mode, target }: ResponsiveProps): JSX.Element;
+
+ export declare interface ResponsiveProps {
+     /** Whether the component's children should be displayed on mobile or desktop mode */
+     mode: ScreenMode;
+     /** The Window element to use to determine the screenMode */
+     target?: Window;
+     /** Content to conditionally render */
+     children: React_2.ReactNode | React_2.ReactNode[];
+ }
+
+ export declare const Row: React_2.ForwardRefExoticComponent<RowProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface RowProps extends ContainerProps {
+     display?: string;
+     flexBasis?: string;
+     flexGrow?: 'unset' | number;
+     flexShrink?: 'unset' | number;
+     order?: 'unset' | number;
+     takeAvailableSpace?: boolean;
+ }
+
+ export declare type ScreenMode = 'mobile' | 'desktop';
+
+ export declare const SearchInput: React_2.ForwardRefExoticComponent<SearchInputProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface SearchInputProps extends ContainerProps {
+     onChange?: () => void;
+     inputRef?: React_2.RefObject<HTMLInputElement>;
+ }
+
+ export declare const Select: React_2.ForwardRefExoticComponent<SelectProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ declare type SelectComponentProps = {
+     label?: string;
+     background?: string | keyof ThemeObj['palette'];
+     disabled?: boolean;
+     items?: SelectItem[];
+     /** Css display property of select */
+     display?: 'block' | 'inline-block';
+     /** Css width property of dropdown */
+     dropdownWidth?: string;
+     /** Css max-width property of dropdown */
+     dropdownMaxWidth?: string;
+     /** Css max-height property of dropdown */
+     dropdownMaxHeight?: string;
+     LabelFactory?: React_2.ComponentType<LabelFactoryProps>;
+     i18nAllLabel?: string;
+     /** Flag to disable the Portal implementation of dropdown */
+     disablePortal?: boolean;
+     /** Whether to show checkboxes */
+     showCheckbox?: boolean;
+     onChange: (arg: SelectItem[] | string | null) => void;
+ } & ({
+     multiple: true;
+     /** Initial selection value */
+     defaultSelection?: SelectItem[];
+     /** Selection value (controlled mode) */
+     selection?: SelectItem[];
+     onChange: (items: SelectItem[]) => void;
+ } | {
+     multiple?: false;
+     /** Initial selection value */
+     defaultSelection?: SelectItem;
+     /** Selection value (controlled mode) */
+     selection?: SelectItem;
+     onChange: (value: string | null) => void;
+ });
+
+ export declare type SelectItem = {
+     label: string;
+     value: string;
+     disabled?: boolean;
+     customComponent?: React_2.ReactElement;
+ };
+
+ export declare type SelectProps = SelectComponentProps & Omit<DropdownProps, keyof SelectComponentProps | 'children'>;
+
+ declare type ShapeType = 'round' | 'square';
+
+ export declare type Shimmer = React_2.VFC<SkeletonProps> & {
+     [K in keyof typeof ShimmerObject]: React_2.VFC<Parameters<typeof ShimmerObject[K]>[number]>;
+ };
+
+ export declare const Shimmer: Shimmer;
+
+ declare const ShimmerObject: {
+     Accordion: ({ width, iconStart, iconEnd, badge }: {
+         width: string;
+         iconStart: boolean;
+         iconEnd: boolean;
+         badge: boolean;
+     }) => JSX.Element;
+     Avatar: ({ size, ...rest }: AvatarSkeletonComponentProps) => JSX.Element;
+     Badge: ({ size, ...rest }: BadgeSkeletonProps) => JSX.Element;
+     Button: ({ size, ...rest }: ButtonSkeletonProps) => JSX.Element;
+     Checkbox: ({ size, ...rest }: IconSkeletonProps) => JSX.Element;
+     EmailChip: ({ width, iconStart, iconEnd, iconEndAdditional }: {
+         width?: string | undefined;
+         iconStart?: boolean | undefined;
+         iconEnd?: boolean | undefined;
+         iconEndAdditional?: boolean | undefined;
+     }) => JSX.Element;
+     FormSection: StyledComponent<React_2.ForwardRefExoticComponent<FormElementProps & React_2.RefAttributes<HTMLDivElement>>, DefaultTheme, {
+     variant: string;
+     backgroundSize: string;
+     }, never>;
+     FormSubSection: StyledComponent<React_2.ForwardRefExoticComponent<FormElementProps & React_2.RefAttributes<HTMLDivElement>>, DefaultTheme, {
+     variant: string;
+     backgroundSize: string;
+     }, never>;
+     Icon: ({ size, ...rest }: IconSkeletonProps) => JSX.Element;
+     Input: ({ width, checkbox }: {
+         width?: string | undefined;
+         checkbox?: boolean | undefined;
+     }) => JSX.Element;
+     ListItem: ({ width, type }: {
+         width?: string | undefined;
+         type?: number | undefined;
+     }) => JSX.Element;
+     Logo: ({ size, ...rest }: LogoSkeletonProps) => JSX.Element;
+     Text: StyledComponent<"div", DefaultTheme, SkeletonProps, never>;
+     Quota: (props: SkeletonProps) => JSX.Element;
+     Searchbar: (props: SkeletonProps) => JSX.Element;
+     Snackbar: ({ width, elementStart, elementEnd }: {
+         width?: string | undefined;
+         elementStart?: boolean | undefined;
+         elementEnd?: boolean | undefined;
+     }) => JSX.Element;
+     Stepper: ({ size, steppersNumber, ...rest }: AvatarSkeletonComponentProps & {
+         steppersNumber: number;
+     }) => JSX.Element;
+     TableListItem: ({ width, type }: {
+         width?: string | undefined;
+         type?: number | undefined;
+     }) => JSX.Element;
+ };
+
+ declare const SIZES: {
+     readonly small: 5;
+     readonly medium: 10;
+     readonly large: 15;
+ };
+
+ export declare type SkeletonProps = {
+     variant?: string;
+     backgroundSize?: string;
+     radius?: string;
+     orientation?: string;
+     mainAlignment?: string;
+     width?: string;
+     height?: string;
+ };
+
+ export declare const Snackbar: React_2.ForwardRefExoticComponent<SnackbarProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare function SnackbarManager({ children, autoHideDefaultTimeout }: SnackbarManagerProps): JSX.Element;
+
+ export declare const SnackbarManagerContext: React_2.Context<CreateSnackbarFn>;
+
+ export declare interface SnackbarManagerProps {
+     autoHideDefaultTimeout?: number;
+     children: React_2.ReactNode | React_2.ReactNode[];
+ }
+
+ export declare interface SnackbarProps extends ContainerProps {
+     /** Whether to show the Snackbar or not */
+     open?: boolean;
+     /** Snackbar Type */
+     type?: 'success' | 'info' | 'warning' | 'error';
+     /** Snackbar text message */
+     label: string;
+     /** Snackbar button text */
+     actionLabel?: string;
+     /** Button's click callback */
+     onActionClick?: () => void;
+     /** Callback to handle Snackbar closing */
+     onClose?: () => void;
+     /** Disable the autoHide functionality */
+     disableAutoHide?: boolean;
+     /** Hide the button in the Snackbar */
+     hideButton?: boolean;
+     /** zIndex of the snackbar */
+     zIndex?: number;
+     /** autoHide timing in milliseconds */
+     autoHideTimeout?: number;
+     /** Window object to use as reference to determine the screenMode */
+     target?: Window;
+     /** Flag to disable the Portal implementation */
+     disablePortal?: boolean;
+     /** Flag to disable the multiline implementation */
+     singleLine?: boolean;
+ }
+
+ export declare const Spinner: React_2.ForwardRefExoticComponent<SpinnerProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface SpinnerProps extends HTMLAttributes<HTMLDivElement> {
+     color: string | keyof ThemeObj['palette'];
+ }
+
+ declare type StyleObj = HTMLAttributes<HTMLDivElement>['style'];
+
+ declare const STYLES: Record<Partial<CSSStyleDeclaration['transition']>, {
+     from: CSSObject;
+     to: CSSObject;
+     end?: CSSObject;
+ } & CSSObject & {
+     transitionDuration?: number;
+ }>;
+
+ export declare const Switch: React_2.ForwardRefExoticComponent<SwitchProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface SwitchProps extends Omit<ContainerProps, 'onChange' | 'onClick'> {
+     /** status of the Switch */
+     defaultChecked?: boolean;
+     /** Switch value */
+     value?: boolean;
+     /** Switch text */
+     label?: string;
+     /** Switch padding */
+     padding?: ContainerProps['padding'];
+     /** whether to disable the Switch or not */
+     disabled?: boolean;
+     /** click callback */
+     onClick?: (event: Event) => void;
+     /** change callback */
+     onChange?: (checked: boolean) => void;
+     /** available sizes */
+     size?: SwitchSize;
+     /** icon color */
+     iconColor?: keyof ThemeObj['palette'];
+ }
+
+ declare type SwitchSize = 'medium' | 'small';
+
+ export declare const TabBar: React_2.ForwardRefExoticComponent<TabBarProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface TabBarProps extends Omit<ContainerProps, 'onChange'> {
+     /** List of elements, can have extra attributes to pass down to the CustomComponent */
+     items: Array<Item>;
+     /** id of the selected item */
+     selected?: string;
+     /** id of the default selected item */
+     defaultSelected?: string;
+     /** change callback, is called with the new selected id */
+     onChange: (selectedId: string) => void;
+     /** click (or also keyboard in the default component) event,
+      * the selectedItemId field is added to the event object */
+     onItemClick: (ev: React_2.SyntheticEvent & {
+         selectedItemId: string;
+     }) => void;
+     /** background color of the tabBar */
+     background: string | keyof ThemeObj['palette'];
+     /** underline color of the selected tab */
+     underlineColor?: string | keyof ThemeObj['palette'];
+     /** Force tabs to have all the same width */
+     forceWidthEquallyDistributed?: boolean;
+ }
+
+ export declare const Table: React_2.ForwardRefExoticComponent<TableProps & React_2.RefAttributes<HTMLTableElement>>;
+
+ export declare interface TableProps extends HTMLAttributes<HTMLDivElement> {
+     /** Table rows */
+     rows?: TRow[];
+     /** Table headers */
+     headers?: THeader[];
+     /** Whether the table should show checkboxes */
+     showCheckbox?: boolean;
+     /** Function to generate the single row */
+     RowFactory?: React_2.ComponentType<TRowProps>;
+     /** Function to generate the table head section */
+     HeaderFactory?: React_2.ComponentType<THeaderProps>;
+     /** Callback function, called when user changes selection of rows in table. */
+     onSelectionChange?: (ids: string[]) => void;
+     /** Row selected by default in the table (Array of rows ids). */
+     defaultSelection?: string[];
+     /** Array of the selected rows (Array of rows ids). To use only if you want the table to be in controlled mode. */
+     selectedRows?: string[];
+     /** Whether multiple rows are selectable. */
+     multiSelect?: boolean;
+ }
+
+ declare const Text_2: React_2.ForwardRefExoticComponent<TextProps & React_2.RefAttributes<HTMLDivElement>>;
+ export { Text_2 as Text }
+
+ declare type TextOverflow = 'ellipsis' | 'break-word';
+
+ export declare interface TextProps extends HTMLAttributes<HTMLDivElement> {
+     /** Text color */
+     color?: string | keyof ThemeObj['palette'];
+     /** Text size */
+     size?: keyof ThemeObj['sizes']['font'];
+     /** Text weight */
+     weight?: keyof ThemeObj['fonts']['weight'];
+     /** Overflow handling */
+     overflow?: TextOverflow;
+     /** Disabled status */
+     disabled?: boolean;
+     /** Content of the text */
+     children?: React_2.ReactNode;
+ }
+
+ export declare const TextWithTooltip: React_2.ForwardRefExoticComponent<TextWithTooltipProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface TextWithTooltipProps extends TextProps {
+     /** Text content */
+     children: string | React_2.ReactNode;
+     tooltipMaxWidth?: string;
+     tooltipPlacement?: Placement;
+     /** Tooltip delay */
+     triggerDelay?: number;
+ }
+
+ export declare type THeader = {
+     id: string;
+     label: string;
+     /** th align attribute */
+     align?: React_2.ThHTMLAttributes<HTMLTableHeaderCellElement>['align'];
+     /** th width attribute */
+     width?: string;
+     /** Select 'All' label translation */
+     i18nAllLabel?: string;
+     /** Select.propTypes.items */
+     items?: SelectProps['items'];
+     /** Whether the label should be bold */
+     bold?: boolean;
+     /** De/Select all rows callback */
+     onChange: SelectProps['onChange'];
+ };
+
+ export declare interface THeaderProps {
+     headers: THeader[];
+     onChange: () => void;
+     allSelected: boolean;
+     selectionMode: boolean;
+     multiSelect: boolean;
+     showCheckbox: boolean;
+ }
+
+ export declare type Theme = ThemeObj;
+
+ declare interface ThemeColorObj {
+     regular: string;
+     hover: string;
+     active: string;
+     focus: string;
+     disabled: string;
+ }
+
+ export { ThemeContext }
+
+ declare interface ThemeObj {
+     windowObj: Window;
+     breakpoints: {
+         width: number;
+         aspectRatio: number;
+     };
+     borderRadius: string;
+     fonts: {
+         default: string;
+         weight: {
+             light: number;
+             regular: number;
+             medium: number;
+             bold: number;
+         };
+     };
+     sizes: {
+         font: ThemeSizeObjExtended;
+         icon: ThemeSizeObj;
+         avatar: Omit<ThemeSizeObjExtended<{
+             diameter: string;
+             font: string;
+         }>, 'extrasmall'>;
+         padding: ThemeSizeObjExtended;
+     };
+     icons: Record<string, IconComponent>;
+     loginBackground: string;
+     logo: {
+         svg: IconComponent;
+         size: ThemeSizeObj;
+     };
+     palette: Record<'currentColor' | 'transparent' | 'primary' | 'secondary' | 'header' | 'highlight' | 'gray0' | 'gray1' | 'gray2' | 'gray3' | 'gray4' | 'gray5' | 'gray6' | 'warning' | 'error' | 'success' | 'info' | 'text', ThemeColorObj>;
+     avatarColors: Record<`avatar_${number}`, string>;
+ }
+
+ declare type ThemePaletteColorKey = keyof ThemePaletteObj;
+
+ declare type ThemePaletteObj = ThemeObj['palette'];
+
+ export declare const ThemeProvider: React_2.FC<ThemeProviderProps>;
+
+ export declare interface ThemeProviderProps {
+     extension?: (theme: ThemeObj) => ThemeObj;
+     loadDefaultFont?: boolean;
+ }
+
+ declare interface ThemeSizeObj<T = string> {
+     small: T;
+     medium: T;
+     large: T;
+ }
+
+ declare interface ThemeSizeObjExtended<T = string> extends ThemeSizeObj<T> {
+     extrasmall: T;
+     extralarge: T;
+ }
+
+ export declare const Tooltip: React_2.ForwardRefExoticComponent<TooltipProps & React_2.RefAttributes<HTMLDivElement>>;
+
+ export declare interface TooltipProps extends TextProps {
+     /** Tooltip text */
+     label: string | React_2.ReactNode | undefined;
+     /** Tooltip placement */
+     placement?: Placement_2;
+     /** Fallback placements to use when tooltip cannot fit in the primary placement */
+     fallbackPlacements?: Placement_2[];
+     /** Tooltip max-width css property */
+     maxWidth?: string;
+     /** Whether to disable the tooltip and render only the child component */
+     disabled?: boolean;
+     /** Flag to disable the Portal implementation */
+     disablePortal?: boolean;
+     /** Show tooltip only when child has class Text and text content is partially hidden */
+     overflowTooltip?: boolean;
+     /** Tooltip trigger */
+     children: React_2.ReactElement;
+     /** time before tooltip shows, in milliseconds */
+     triggerDelay?: number;
+ }
+
+ export declare const Transition: ForwardRefExoticComponent<PropsWithoutRef<TransitionProps> & RefAttributes<HTMLElement>> & {
+     types?: Array<keyof typeof STYLES>;
+ };
+
+ declare interface TransitionOnProps {
+     /** Transition type, one of the default ones. Ignore if is a custom Transition */
+     type?: keyof typeof STYLES;
+     /** Initial styles of the component to which apply the Transition */
+     from?: CSSObject;
+     /** Final styles of the component to which apply the Transition */
+     to?: CSSObject;
+     /** Styles to keep after the Transition */
+     end?: CSSObject;
+     /** Whether to apply the Transition. If not applied, the component maybe not be visible. */
+     apply?: boolean;
+     /** Custom transition css target (all, opacity...). */
+     transitionTarget?: CSSStyleDeclaration['transitionProperty'];
+     /** Custom transition css timing (ease-in, ease-out...). */
+     transitionTiming?: CSSStyleDeclaration['transitionTimingFunction'];
+     /** Custom transition css duration in ms */
+     transitionDuration?: number;
+     /** Custom transition css delay in ms */
+     transitionDelay?: CSSStyleDeclaration['transitionDelay'] | number;
+     /** Children */
+     children: JSX.Element;
+ }
+
+ export declare interface TransitionProps extends TransitionOnProps {
+     /** Turn off the Transition */
+     disabled?: boolean;
+ }
+
+ export declare type TRow = {
+     id: string;
+     /** Each column can be a string or a React component */
+     columns: Array<string | React_2.ReactElement>;
+     /** Whether to highlight this row */
+     highlight?: boolean;
+     /** Whether the row is clickable */
+     clickable?: boolean;
+     /** Row click callback */
+     onClick?: React_2.ReactEventHandler;
+ };
+
+ export declare interface TRowProps {
+     index: number;
+     row: TRow;
+     onChange: (id: string) => void;
+     selected: boolean;
+     selectionMode: boolean;
+     multiSelect: boolean;
+     showCheckbox: boolean;
+ }
+
+ export declare function useCheckbox({ ref, value, defaultChecked, disabled, onClick, onChange }: UseCheckboxArgs): boolean;
+
+ export declare type UseCheckboxArgs = {
+     ref: React_2.RefObject<HTMLElement>;
+     value?: boolean;
+     defaultChecked?: boolean;
+     disabled?: boolean;
+     onClick?: (event: Event) => void;
+     onChange?: (newValue: boolean) => void;
+ };
+
+ export declare function useCombinedRefs<T>(...refs: React_2.ForwardedRef<T>[]): React_2.RefObject<T>;
+
+ export declare function useHiddenCount(containerRef: React_2.RefObject<HTMLElement>, listenForWindowResize: boolean): [number, () => void];
+
+ export declare const useIsVisible: <T extends HTMLElement>(listRef: React_2.RefObject<HTMLDivElement>) => [boolean, React_2.RefObject<T>];
+
+ export declare function useKeyboard(ref: React_2.RefObject<HTMLElement>, events: KeyboardPreset): void;
+
+ export declare function useModal(): CreateModalFn;
+
+ export declare function useScreenMode(target?: Window): ScreenMode;
+
+ export declare function useSnackbar(): CreateSnackbarFn;
+
+ export declare function useSplitVisibility<T, R extends HTMLElement = HTMLElement>(items: T[], optionsWithRetroCompatibility?: Options | 'end' | 'start'): [T[], T[], React_2.RefObject<R>];
+
+ export declare const useTheme: () => ThemeObj;
+
+ export declare function ZimbraClassicThemeContextProvider({ styleSheetTarget, children, extension, loadDefaultFont }: ZimbraClassicThemeContextProviderProps): JSX.Element;
+
+ export declare interface ZimbraClassicThemeContextProviderProps {
+     styleSheetTarget?: HTMLElement;
+     children: React_2.ReactElement;
+     extension?: (theme: ThemeObj) => ThemeObj;
+     loadDefaultFont?: boolean;
+ }
+
+ export { }