@groupeactual/ui-kit 1.7.10 → 2.0.0-beta.1

package/dist/es/index.d.ts

@@ -1,34 +1,34 @@
-import React, { ReactNode, FocusEventHandler, BaseSyntheticEvent, MouseEventHandler, MouseEvent, PropsWithChildren } from 'react';
-import { TypographyProps, LinkProps, ButtonProps, TextFieldProps, SelectProps, CheckboxProps, RadioGroupProps, AccordionProps, BreadcrumbsProps, BoxProps, ChipProps, TooltipProps, AutocompleteProps, MenuItemProps, AlertProps, SxProps, Theme as Theme$1, CardProps, SwitchProps, IconButtonProps } from '@mui/material';
+import React, { ReactNode, FocusEventHandler, BaseSyntheticEvent, MouseEventHandler, MouseEvent, SyntheticEvent, PropsWithChildren } from 'react';
+import { TypographyProps, LinkProps, ButtonProps, OutlinedInputProps, SelectProps, CheckboxProps, RadioGroupProps, AccordionProps, BreadcrumbsProps, ChipProps, BoxProps, TooltipProps, AutocompleteProps, MenuItemProps, AlertProps, SxProps, Theme, CardProps, SwitchProps, TextFieldProps, IconButtonProps, PaletteMode } from '@mui/material';
 import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
 import { CustomContentProps } from 'notistack';
 import { ModalProps as ModalProps$1 } from '@mui/material/Modal';
 import { DatePickerProps } from '@mui/x-date-pickers-pro';
 import { Dayjs } from 'dayjs';
+import { Theme as Theme$1 } from '@groupeactual/design-tokens';
 
 interface Props$q extends Omit<TypographyProps, 'variant'> {
-    variant?: 'bigNumber' | 'body1' | 'body1Regular' | 'body1Medium' | 'body1Bold' | 'body2' | 'body2Regular' | 'body2Medium' | 'body2Bold' | 'caption' | 'buttonNotif' | 'header1' | 'header2' | 'header3' | 'header4' | 'h1' | 'h2' | 'h3' | 'h4' | 'link1' | 'link2';
+    variant?: 'bigNumber' | 'body1' | 'body1Medium' | 'body1Bold' | 'body2' | 'body2Medium' | 'body2Bold' | 'h1' | 'h2' | 'h3' | 'h4' | 'caption' | 'buttonNotif' | 'link1' | 'link2';
     component?: any;
 }
-declare const Text: (props: Props$q) => React.JSX.Element;
+declare const Text: React.ForwardRefExoticComponent<Omit<Props$q, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
 interface Props$p extends Omit<LinkProps, 'variant'> {
     variant?: 'link1' | 'link2';
-    component?: any;
 }
-declare const Link: (props: Props$p) => React.JSX.Element;
+declare const Link: React.ForwardRefExoticComponent<Omit<Props$p, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
 
 interface Props$o extends Omit<ButtonProps, 'variant' | 'children'> {
-    variant?: 'primary' | 'secondary';
+    variant?: 'primary' | 'secondary' | 'tertiary' | 'destructive';
     children?: ReactNode;
 }
-declare const Button: ({ variant, children, ...props }: Props$o) => React.JSX.Element;
+declare const Button: React.ForwardRefExoticComponent<Omit<Props$o, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
-interface Props$n extends Omit<TextFieldProps, 'error'> {
-    error?: string;
-    label?: string;
+interface Props$n extends Omit<OutlinedInputProps, 'error'> {
+    label?: ReactNode;
     value?: string | unknown;
     name?: string;
+    error?: string;
     placeholder?: string;
     disabled?: boolean;
     endAdornment?: ReactNode;
@@ -36,17 +36,18 @@ interface Props$n extends Omit<TextFieldProps, 'error'> {
     width?: number | string;
     className?: string;
     focused?: boolean;
+    helperText?: string;
     onClick?: (_e: React.MouseEvent<HTMLInputElement>) => void;
     onBlur?: FocusEventHandler<unknown>;
     onChange?: (_e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
 }
-declare const TextField: React.ForwardRefExoticComponent<Props$n & React.RefAttributes<HTMLDivElement>>;
+declare const TextField: React.ForwardRefExoticComponent<Props$n & React.RefAttributes<HTMLInputElement | HTMLTextAreaElement>>;
 
 interface Props$m<T> extends Omit<SelectProps<T>, 'value' | 'onChange' | 'color' | 'error'> {
+    label?: ReactNode;
     options: T[];
     placeholder?: string;
     disabled?: boolean;
-    label?: string;
     helperText?: string;
     color?: 'success';
     value: T | undefined;
@@ -59,10 +60,10 @@ interface Props$m<T> extends Omit<SelectProps<T>, 'value' | 'onChange' | 'color'
     onBlur?: (_event: BaseSyntheticEvent) => void;
     onClick?: (_event: BaseSyntheticEvent) => void;
 }
-declare const Select: <T>({ value, label, options, color, error, placeholder, helperText, width, disabled, popupIcon, onChange, getRenderValue, ...props }: Props$m<T>) => React.JSX.Element;
+declare const Select: <T>(_props: Props$m<T> & React.RefAttributes<HTMLSelectElement>) => React.ReactNode;
 
 interface Props$l<T> extends Omit<SelectProps<T[]>, 'value' | 'onChange' | 'value' | 'color' | 'error'> {
-    label: string;
+    label: ReactNode;
     options: T[] | [];
     helperText?: string;
     color?: 'success';
@@ -77,7 +78,7 @@ interface Props$l<T> extends Omit<SelectProps<T[]>, 'value' | 'onChange' | 'valu
     getRenderValue: (_option: T) => string;
     getKeyValue: (_option: T) => string;
 }
-declare const MultiSelect: <T>({ value, label, options, color, error, placeholder, helperText, width, getRenderValue, getKeyValue, onChange, disabled, ...props }: Props$l<T>) => React.JSX.Element;
+declare const MultiSelect: <T>(_props: Props$l<T> & React.RefAttributes<HTMLSelectElement>) => React.ReactNode;
 
 interface Props$k {
     name: string;
@@ -86,44 +87,38 @@ interface Props$k {
     onChange?: (_field: string, _value: boolean, _shouldValidate?: boolean | undefined) => void;
     helperText?: string;
     error?: string;
-    infoBubbleContent?: string;
-    infoBubblePosition?: 'top' | 'right' | 'bottom' | 'left' | 'bottom-end' | 'bottom-start' | 'left-end' | 'left-start' | 'right-end' | 'right-start' | 'top-end' | 'top-start' | undefined;
 }
-declare const Checkbox: ({ name, value, error, helperText, label, infoBubbleContent, infoBubblePosition, onChange, disabled, ...props }: CheckboxProps & Props$k) => React.JSX.Element;
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & Props$k & React.RefAttributes<HTMLDivElement>>;
 
 interface CheckboxItemType {
     label: ReactNode;
     value: boolean;
     name: string;
-    infoBubbleContent?: string;
-    infoBubblePosition?: 'right' | 'bottom' | 'left' | 'top' | 'bottom-end' | 'bottom-start' | 'left-end' | 'left-start' | 'right-end' | 'right-start' | 'top-end' | 'top-start' | undefined;
 }
 
 interface CheckboxGroupProps {
-    label: string;
+    label?: ReactNode;
     options: CheckboxItemType[];
     disabled?: boolean;
     error?: string;
     helperText?: string;
-    onChange?: (_selectedOptions: Record<string, boolean>) => void;
+    onChange?: (_selectedOptionsNameValue: Record<string, boolean>, _updatedOptions: CheckboxItemType[], _updatedIndexOptions: number) => void;
 }
-declare const CheckboxGroup: ({ options, label, disabled, error, helperText, onChange, }: CheckboxGroupProps) => React.JSX.Element;
+declare const CheckboxGroup: React.ForwardRefExoticComponent<CheckboxGroupProps & React.RefAttributes<HTMLDivElement>>;
 
 interface ItemType<T> {
-    label: string;
+    label?: ReactNode;
     value: T;
-    infoBubbleContent?: string;
-    infoBubblePosition?: 'top' | 'right' | 'bottom' | 'left' | 'bottom-end' | 'bottom-start' | 'left-end' | 'left-start' | 'right-end' | 'right-start' | 'top-end' | 'top-start' | undefined;
 }
 interface Props$j<T> extends Omit<RadioGroupProps, 'onChange'> {
-    label: string;
+    label?: ReactNode;
     options: ItemType<T>[];
     onChange: (_value: T) => void;
     error?: string;
     helperText?: string;
     disabled?: boolean;
 }
-declare const RadioGroup: <T>({ options, value, label, onChange, helperText, disabled, error, ...props }: Props$j<T>) => React.JSX.Element;
+declare const RadioGroup: <T>(_props: Props$j<T> & React.RefAttributes<HTMLTableElement>) => React.ReactNode;
 
 interface Props$i extends AccordionProps {
     title?: string;
@@ -133,36 +128,21 @@ interface Props$i extends AccordionProps {
     disabled?: boolean;
     onClick?: MouseEventHandler;
 }
-declare const Accordion: ({ title, summaryHeight, expanded, onClick, children, ...props }: Props$i) => React.JSX.Element;
+declare const Accordion: React.ForwardRefExoticComponent<Props$i & React.RefAttributes<HTMLDivElement>>;
 
 interface LinkItem {
     link: string;
     title: string;
 }
 interface Props$h extends BreadcrumbsProps {
-    PageName: string;
+    currentPage: string;
     links?: LinkItem[];
 }
-declare const Breadcrumbs: ({ PageName, links, ...props }: Props$h) => React.JSX.Element;
+declare const Breadcrumbs: React.ForwardRefExoticComponent<Props$h & React.RefAttributes<HTMLDivElement>>;
 
-declare const FontSizes: {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-    xxxl: number;
-};
-interface Props$g {
-    variant?: 'square' | 'none';
-    icon: IconDefinition;
-    color?: string;
-    size?: number | keyof typeof FontSizes;
-}
-declare const IconProvider: ({ variant, icon, color, size, sx, ...props }: Props$g & BoxProps) => JSX.Element;
+declare const IconProvider: React.ForwardRefExoticComponent<any>;
 
-interface Props$f {
+interface Props$g {
     totalString: string;
     totalPerPageString: string;
     totalRows: number;
@@ -170,12 +150,13 @@ interface Props$f {
     limitsPerPage?: number[];
     page?: number;
     limit?: number;
+    disabled?: boolean;
     setPage?: (_page: number) => void;
     setLimit?: (_limit: number) => void;
 }
-declare const Pagination: ({ totalString, totalPerPageString, hideTotal, limitsPerPage, page, totalRows, limit, setLimit, setPage, }: Props$f) => React.JSX.Element;
+declare const Pagination: React.ForwardRefExoticComponent<Props$g & React.RefAttributes<HTMLDivElement>>;
 
-interface Props$e extends Omit<ChipProps, 'suffix' | 'prefix' | 'onDelete' | 'onDeleteIcon' | 'variant'> {
+interface Props$f extends Omit<ChipProps, 'suffix' | 'prefix' | 'onDelete' | 'onDeleteIcon' | 'variant'> {
     variant: 'filled' | 'outlined' | 'status' | 'statusFilled';
     label: string;
     prefixIcon?: IconDefinition;
@@ -186,57 +167,64 @@ interface Props$e extends Omit<ChipProps, 'suffix' | 'prefix' | 'onDelete' | 'on
     maxWidth?: string | number;
     maxLength?: number;
 }
-declare const Chip: ({ variant, label, prefixIcon, suffixIcon, suffixTooltip, suffixAction, tooltip, maxWidth, ...props }: Props$e) => React.JSX.Element;
+declare const Chip: React.ForwardRefExoticComponent<Omit<Props$f, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
-interface Props$d extends BoxProps {
+interface Props$e extends BoxProps {
     variant: 'warning' | 'error' | 'success' | 'infos';
     title: string;
     text?: ReactNode;
     actionButton?: ReactNode;
 }
-declare const EmbeddedNotification: ({ title, text, variant, actionButton, ...props }: Props$d) => React.JSX.Element;
+declare const EmbeddedNotification: React.ForwardRefExoticComponent<Props$e & React.RefAttributes<HTMLDivElement>>;
 
 type Placement = 'right' | 'bottom' | 'left' | 'top' | 'bottom-end' | 'bottom-start' | 'left-end' | 'left-start' | 'right-end' | 'right-start' | 'top-end' | 'top-start' | undefined;
 
-interface Props$c extends Omit<TooltipProps, 'icon' | 'children' | 'placement'> {
+interface Props$d extends Omit<TooltipProps, 'icon' | 'children' | 'placement'> {
     title: ReactNode;
     children: ReactNode;
     placement?: Placement;
     placementMargin?: number;
 }
-declare const Tooltip: ({ title, placement, children, placementMargin, ...tooltipProps }: Props$c) => React.JSX.Element;
+declare const Tooltip: React.ForwardRefExoticComponent<Props$d & React.RefAttributes<HTMLDivElement>>;
 
-interface Props$b<T> extends Omit<AutocompleteProps<T, false, false, false>, 'onChange' | 'value' | 'options' | 'renderInput' | 'error' | 'getOptionLabel'> {
-    label: string;
+interface Props$c<T> extends Omit<AutocompleteProps<T, false, false, false>, 'onChange' | 'value' | 'options' | 'renderInput' | 'error' | 'getOptionLabel'> {
+    label?: ReactNode;
     options: T[];
     helperText?: string;
     color?: 'success';
     placeholder?: string;
-    getOptionLabel: (_option: T) => string | null | undefined;
-    onChange: (_value: T | null) => void;
     value?: T | null;
     width?: number | string;
     error?: string;
     searchIcon?: boolean;
+    icon?: ReactNode;
+    getOptionGroupLabel?: (_option: T) => string;
+    handleOptionChip?: (_option: T) => ReactNode | undefined;
+    getOptionLabel: (_option: T) => string | null | undefined;
+    onChange: (_value: T | null) => void;
 }
-declare const AutoCompleteSingle: <T>({ value, label, placeholder, options, disabled, getOptionLabel, onChange, width, color, helperText, error, searchIcon, ...props }: Props$b<T>) => React.JSX.Element;
+declare const AutoCompleteSingle: <T>(_props: Props$c<T> & React.RefAttributes<HTMLSelectElement>) => React.ReactNode;
 
-interface AutocompleteMultipleSelectProps<T> extends Omit<AutocompleteProps<T, true, true, false>, 'onChange' | 'value' | 'options' | 'renderInput' | 'error' | 'autocomplete' | 'searchIcon'> {
+interface Props$b<T> extends Omit<AutocompleteProps<T, true, true, false>, 'onChange' | 'value' | 'options' | 'renderInput' | 'error' | 'autocomplete' | 'searchIcon'> {
     value: T[] | undefined;
-    label?: string;
+    label?: ReactNode;
     helperText?: string;
     placeholder?: string;
     options: T[];
-    getOptionLabel: (_option: T) => string;
-    getKeyValue: (_option: T) => string;
-    onChange: (_value: T[]) => void;
-    getOptionDisabled?: (_option: T) => boolean;
     color?: 'success';
     width?: number | string;
     error?: string;
     searchIcon?: boolean;
+    icon?: ReactNode;
+    isOptionEqualToValue?: (_option: T, _value: T) => boolean;
+    getOptionLabel: (_option: T) => string;
+    getKeyValue: (_option: T) => string;
+    onChange: (_value: T[]) => void;
+    getOptionDisabled?: (_option: T) => boolean;
+    getOptionGroupLabel?: (_option: T) => string;
+    handleOptionChip?: (_option: T) => ReactNode | undefined;
 }
-declare const AutocompleteMultipleSelect: <T>({ value, label, placeholder, options, disabled, getOptionLabel, getKeyValue, onChange, getOptionDisabled, width, color, helperText, error, searchIcon, ...props }: AutocompleteMultipleSelectProps<T>) => React.JSX.Element;
+declare const AutoCompleteMulti: <T>(_props: Props$b<T> & React.RefAttributes<HTMLSelectElement>) => React.ReactNode;
 
 interface AcceptTextType {
     fileFormat?: string;
@@ -276,21 +264,20 @@ interface Props$a {
     onTouched?: () => void;
     onFilesDataChange?: (_fileData: FileDataType[] | undefined) => void;
 }
-declare const FileUploader: ({ title, subTitle, titleAddButton, helperText, titleTooltip, files, isMulti, accept, acceptText, orText, fromLocalText, fromGoogleDriveText, disabled, error, enableGoogleDrive, googleAuthClientId, googleApiKey, _isDroppingFile, validateFile, onTouched, onFilesDataChange, }: Props$a) => React.JSX.Element;
+declare const FileUploader: React.ForwardRefExoticComponent<Props$a & React.RefAttributes<HTMLDivElement>>;
 
 interface Props$9 extends Omit<MenuItemProps, 'onClick'> {
-    onClick: (_event?: React.MouseEvent<HTMLElement>) => void;
+    onClick?: (_event?: React.MouseEvent<HTMLLIElement>) => void;
+    selected?: boolean;
     children: NonNullable<ReactNode>;
-    testId?: string;
-    disabled?: boolean;
 }
-declare const MenuItem: ({ onClick, children, testId, disabled, ...props }: Props$9) => React.JSX.Element;
+declare const MenuItem: React.ForwardRefExoticComponent<Omit<Props$9, "ref"> & React.RefAttributes<HTMLLIElement>>;
 
 interface Props$8 extends Omit<AlertProps, 'severity' | 'text'> {
     text: string | React.ReactNode;
     severity: 'success' | 'warning' | 'error' | 'info';
 }
-declare const Snackbar: ({ text, severity }: Props$8) => React.JSX.Element;
+declare const Snackbar: React.ForwardRefExoticComponent<Props$8 & React.RefAttributes<HTMLDivElement>>;
 
 declare const NotistackAdapter: React.ForwardRefExoticComponent<CustomContentProps & React.RefAttributes<HTMLDivElement>>;
 
@@ -298,7 +285,7 @@ interface Props$7 extends AlertProps {
     text: string;
     onClose?: () => void;
 }
-declare const BannerNotification: ({ text, severity, onClose }: Props$7) => React.JSX.Element;
+declare const BannerNotification: React.ForwardRefExoticComponent<Props$7 & React.RefAttributes<HTMLDivElement>>;
 
 interface StepperItem {
     label: string;
@@ -316,9 +303,9 @@ interface Props$6 {
     steps: Step[];
     canNavigate: boolean;
     onNavigate?: (_url: string) => void;
-    sx?: SxProps<Theme$1>;
+    sx?: SxProps<Theme>;
 }
-declare const Stepper: ({ steps, canNavigate, onNavigate, sx, }: Props$6) => React.JSX.Element;
+declare const Stepper: React.ForwardRefExoticComponent<Props$6 & React.RefAttributes<HTMLDivElement>>;
 
 interface ModalProps extends Omit<ModalProps$1, 'component' | 'open' | 'className' | 'onClose'> {
     open: boolean;
@@ -335,34 +322,37 @@ interface DrawerProps extends Omit<ModalProps, 'icon'> {
     hideCloseButton?: boolean;
 }
 
-declare const Drawer: ({ title, open, hideCloseButton, titleLeftComponent, footer, cardProps, size, children, onClose, ...props }: DrawerProps) => React.JSX.Element;
+declare const Drawer: React.ForwardRefExoticComponent<Omit<DrawerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
-declare const Dialog: ({ title, open, onClose, children, icon, ...props }: Omit<ModalProps, "footer" | "cardProps" | "size" | "component">) => React.JSX.Element;
+declare const Dialog: React.ForwardRefExoticComponent<Omit<Omit<ModalProps, "component" | "size" | "footer" | "cardProps">, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
 interface Props$5 {
-    label: string;
+    label?: ReactNode;
+    helperText?: string;
     checked: boolean;
     leftSideLabel?: string;
     onClick: () => void;
 }
-declare const Switch: ({ label, checked, leftSideLabel, onClick, ...props }: SwitchProps & Props$5) => React.JSX.Element;
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & Props$5 & React.RefAttributes<HTMLButtonElement>>;
 
 interface Props$4<T extends Dayjs> extends Omit<DatePickerProps<T>, 'onChange' | 'width'> {
+    label?: ReactNode;
     value: T | null | undefined;
-    onChange: (_value: T | null | undefined) => void;
+    disabled?: boolean;
     error?: string;
-    success?: boolean;
+    color?: 'primary' | 'secondary' | 'error' | 'info' | 'success' | 'warning';
     helperText?: string;
     width?: string;
     locale?: 'fr' | 'en';
+    onChange: (_value: T | null | undefined) => void;
 }
-declare const DatePicker: <T extends Dayjs>({ value, onChange, error, success, helperText, width, locale, ...props }: Props$4<T>) => React.JSX.Element;
+declare const DatePicker: <T extends Dayjs>(_props: Props$4<T> & React.RefAttributes<HTMLDivElement>) => React.ReactNode;
 
-interface Props$3 extends Omit<TextFieldProps, 'error' | 'onChange'> {
+interface Props$3 extends Omit<TextFieldProps, 'error' | 'onChange' | 'margin' | 'onInvalid' | 'onKeyDown' | 'onKeyUp' | 'slotProps'> {
     value: Dayjs | undefined;
     onChange?: (_time: string | Dayjs | undefined) => void;
     onTouched?: () => void;
-    label?: string;
+    label?: ReactNode;
     helperText?: string;
     minTime?: Dayjs;
     maxTime?: Dayjs;
@@ -429,7 +419,7 @@ type WithoutDetailsProps<T> = {
 };
 type Props$2<T extends object> = BaseProps<T> & (WithoutPaginationProps | PaginationProps) & (WithDetailsProps<T, RowDetail> | WithoutDetailsProps<T>);
 
-declare const Datatable: <T extends object>({ onLoad, onSort, sortInfo, withHeader, withPagination, columns, isTableLayoutFixed, ...props }: Props$2<T>) => React.JSX.Element;
+declare const Datatable: <T extends object>(_props: Props$2<T> & React.RefAttributes<HTMLTableElement>) => React.ReactNode;
 
 declare const DatatableCellRender: ({ data }: {
     data: string;
@@ -437,79 +427,41 @@ declare const DatatableCellRender: ({ data }: {
 
 interface Props$1 extends Omit<IconButtonProps, 'color'> {
     icon: IconDefinition;
-    variant?: 'default' | 'table';
+    variant?: 'plain' | 'outlined';
     positionGroup?: 'left' | 'middle' | 'right';
     tooltipText?: string;
     tooltipPosition?: Placement;
     size?: 'small' | 'medium';
-    sx?: SxProps<Theme$1>;
-    color?: string;
+    sx?: SxProps<Theme>;
+    color?: 'neutral' | 'success' | 'warning' | 'danger';
     onClick?: MouseEventHandler | undefined;
 }
-declare const IconButton: ({ icon, variant, positionGroup, tooltipText, tooltipPosition, size, color, onClick, ...iconButtonProps }: Props$1) => React.JSX.Element;
+declare const IconButton: React.ForwardRefExoticComponent<Omit<Props$1, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+interface TabData {
+    label: string;
+    content: ReactNode;
+}
+interface TabsPanelProps {
+    tabs: TabData[];
+    value?: number;
+    width?: string | number;
+    disabled?: boolean;
+    onChange?: (_event: SyntheticEvent, _newValue: number) => void;
+}
+
+declare const TabsPanel: React.ForwardRefExoticComponent<TabsPanelProps & React.RefAttributes<HTMLDivElement>>;
 
-type Theme = 'Default' | 'Ep';
 interface DesignSystemContextValues {
-    isDarkTheme: boolean;
-    themeName: Theme;
-    toggleDarkTheme: () => void;
+    themeName: Theme$1;
+    mode: PaletteMode;
 }
 declare const DesignSystemContext: React.Context<DesignSystemContextValues>;
 interface Props {
-    name?: Theme;
-}
-declare const DesignSystemProvider: ({ children, name: themeName, }: PropsWithChildren<Props>) => React.JSX.Element;
-
-interface PaletteDS {
-    redActual: string;
-    blueClickable: string;
-    blueHoverClickable: string;
-    greyMediumInactive: string;
-    greyXDark: string;
-    greyDark: string;
-    white: string;
-    greyXLight: string;
-    greyXDarkBgModal: string;
-    blueHoverEquivalence: string;
-    blueHoverOpacity12: string;
-    greyLightDefaultBorder: string;
-    blueInfo: string;
-    greenSuccess: string;
-    redError: string;
-    orangeWarning: string;
-    blueDark: string;
-    blueMedium: string;
-    blueLight: string;
-    greenDark: string;
-    greenMedium: string;
-    green: string;
-    brown: string;
-    greenLight: string;
-    orangeLight: string;
-    yellow: string;
-    purpleDark: string;
-    purple: string;
-    pink: string;
-    pinkLight: string;
-    primary: {
-        main: string;
-        dark: string;
-    };
-    secondary: {
-        main: string;
-    };
-    success: {
-        main: string;
-    };
-    error: {
-        main: string;
-    };
-    warning: {
-        main: string;
-    };
-    infos: {
-        main: string;
-    };
-}
-
-export { type AcceptTextType, Accordion, AutocompleteMultipleSelect as AutoCompleteMulti, AutoCompleteSingle, BannerNotification, Breadcrumbs, Button, Checkbox, CheckboxGroup, type CheckboxItemType, Chip, Datatable, DatatableCellRender, DatePicker, DesignSystemContext, type DesignSystemContextValues, DesignSystemProvider, Dialog, Drawer, EmbeddedNotification, type FileDataType, FileUploader, IconButton, IconProvider, Link, MenuItem, MultiSelect, NotistackAdapter, Pagination, type PaletteDS, RadioGroup, Select, Snackbar, Stepper, Switch, Text, TextField, TimePicker, Tooltip };
+    themeName?: Theme$1;
+    mode?: PaletteMode;
+}
+declare const DesignSystemProvider: ({ children, themeName, mode, }: PropsWithChildren<Props>) => React.JSX.Element;
+
+export { Accordion, AutoCompleteMulti, AutoCompleteSingle, BannerNotification, Breadcrumbs, Button, Checkbox, CheckboxGroup, Chip, Datatable, DatatableCellRender, DatePicker, DesignSystemContext, DesignSystemProvider, Dialog, Drawer, EmbeddedNotification, FileUploader, IconButton, IconProvider, Link, MenuItem, MultiSelect, NotistackAdapter, Pagination, RadioGroup, Select, Snackbar, Stepper, Switch, TabsPanel, Text, TextField, TimePicker, Tooltip };
+export type { AcceptTextType, CheckboxItemType, DesignSystemContextValues, FileDataType };