@natoora-libs/core 0.2.24-dev-package-upgrades-1 → 0.2.24-dev-doug-1

package/dist/components/index.d.ts

@@ -0,0 +1,1198 @@
+import * as React from 'react';
+import React__default, { MouseEvent, CSSProperties, ReactNode, FC, ReactElement, ComponentType, ChangeEvent, ComponentProps, SVGProps } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { UseFormReturn, Control, ControllerRenderProps, ControllerFieldState, UseFormTrigger, FieldValues, Path } from 'react-hook-form';
+import { H as HeadCell, a as HeaderFilters, b as HeaderFilterOptions, c as HeaderFilterObject, T as TableDesktopProps, O as Order, R as RowId } from '../TableDesktop-BQk0gStR.js';
+export { B as BulkChanges, d as BulkChangesDialogProps, E as EditableCellType, e as ExportCsvDialogProps, f as TableColumnConfigurationMenuProps, g as TableDesktop, h as TableDesktopFooter, i as TableDesktopFooterProps, j as TableDesktopToolbar, k as TableDesktopToolbarProps, U as UpdateEditableCellParams } from '../TableDesktop-BQk0gStR.js';
+import { UseMutateAsyncFunction } from 'react-query';
+import { BoxProps, SxProps, Theme, SelectProps, MenuProps, Typography, AutocompleteProps, TextFieldProps } from '@mui/material';
+import { DateRangePickerShape } from 'react-dates';
+
+type ActiveFiltersIconButtonProps = {
+    label?: string;
+    className?: string;
+    enableRipple?: boolean;
+    numActiveFilters: number;
+    handleClick: (event: MouseEvent<HTMLElement>) => void;
+};
+declare const ActiveFiltersIconButton: React.MemoExoticComponent<({ label, className, enableRipple, numActiveFilters, handleClick, }: ActiveFiltersIconButtonProps) => react_jsx_runtime.JSX.Element>;
+
+type AddressOption = {
+    label: string;
+    placeId: string;
+};
+type ProcessedAddress = {
+    line1?: string;
+    line2?: string;
+    city?: string;
+    county?: string;
+    state?: AddressState | null;
+    country?: {
+        code: string;
+        name: string;
+    };
+    postcode?: string;
+};
+type GoogleAddressComponent = {
+    types: string[];
+    long_name: string;
+    short_name: string;
+};
+type GooglePlacesRawData = {
+    status: string;
+    result: {
+        address_components: GoogleAddressComponent[];
+    };
+};
+type GooglePlacesAddressAutocompleteProps = {
+    apiKey: string;
+    googlePlacesRawData?: GooglePlacesRawData;
+    isGooglePlacesRawDataFetching?: boolean;
+    addressOption: AddressOption | null;
+    onChangeAddressOption: (newAddressOption: AddressOption | null) => void;
+    onAddressSelected?: (processedAddress: ProcessedAddress) => void;
+    onClearAddressOption?: () => void;
+    containerStyles?: CSSProperties;
+};
+declare const GooglePlacesAddressAutocomplete: ({ apiKey, googlePlacesRawData, isGooglePlacesRawDataFetching, addressOption, onChangeAddressOption, onAddressSelected, onClearAddressOption, containerStyles, }: GooglePlacesAddressAutocompleteProps) => react_jsx_runtime.JSX.Element;
+
+type AddressCountry = {
+    code: string;
+    name: string;
+};
+type AddressState = {
+    id: number;
+    name: string;
+    abbreviation?: string | null;
+    country?: string | null;
+};
+type BaseAddressFormFields = {
+    name: string;
+    line1: string;
+    line2?: string | null;
+    primary_phone_number?: string | null;
+    city: string;
+    county?: string | null;
+    postcode: string;
+    country: AddressCountry;
+    state?: AddressState | null;
+};
+type AddressFormFieldsProps = {
+    form: UseFormReturn<BaseAddressFormFields>;
+    countriesSelectProps: {
+        countries: AddressCountry[];
+        isCountriesFetching: boolean;
+        refetchCountries: () => void;
+    };
+    statesSelectProps: {
+        addressStates: AddressState[];
+        isAddressStatesFetching: boolean;
+    };
+    googlePlacesAutocompleteProps?: GooglePlacesAddressAutocompleteProps;
+};
+declare const AddressFormFields: ({ form, countriesSelectProps: { countries, isCountriesFetching, refetchCountries }, statesSelectProps: { addressStates, isAddressStatesFetching }, googlePlacesAutocompleteProps, }: AddressFormFieldsProps) => react_jsx_runtime.JSX.Element;
+
+interface AlertDialogProps {
+    open: boolean;
+    alertTitle?: string;
+    description?: string;
+    maxWidth?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    fullWidth?: boolean;
+    content?: ReactNode;
+    fullScreen?: boolean;
+    handleAlertAccept?: () => void;
+    handleAlertReject?: () => void;
+    rejectCopy?: string;
+    acceptCopy?: string;
+    disabledContentPadding?: boolean;
+    disableEnforceFocus?: boolean;
+    disableRestoreFocus?: boolean;
+}
+declare const AlertDialog: React.FC<AlertDialogProps>;
+
+interface AlertDialogFullScreenProps {
+    acceptCopy?: any;
+    content?: any;
+    fullScreen?: any;
+    handleAlertAccept?: any;
+    handleAlertReject?: any;
+    open?: any;
+    rejectCopy?: any;
+}
+declare const AlertDialogFullScreen: ({ handleAlertAccept, handleAlertReject, fullScreen, open, rejectCopy, acceptCopy, content, }: AlertDialogFullScreenProps) => react_jsx_runtime.JSX.Element;
+
+interface IAppLabel {
+    appName: string;
+}
+declare const AppLabel: ({ appName }: IAppLabel) => react_jsx_runtime.JSX.Element;
+
+type AppliedTableFiltersDisplayProps = {
+    headCells: HeadCell[];
+    headerFilters: HeaderFilters;
+    hasAnyFiltersApplied: boolean;
+    onOpenClearFiltersDialog: () => void;
+};
+declare const AppliedTableFiltersDisplay: FC<AppliedTableFiltersDisplayProps>;
+
+type AutocompleteFilterMenuContentProps = {
+    columnId: string;
+    labelFieldName: string;
+    selectedFilterOptions: HeaderFilterOptions;
+    isLoading?: boolean;
+    maxWidth?: number;
+    maxHeight?: number;
+    onFilterOptionChange: (option: string | HeaderFilterObject) => void;
+    onApplyFiltersClick: (shouldSave: boolean) => void;
+    filterOptions: HeadCell['filterOptions'];
+    onAutocompleteSearch: HeadCell['onAutocompleteSearch'];
+    shouldShowCheckOnFilter?: TableDesktopProps['shouldShowCheckOnFilter'];
+};
+declare const AutocompleteFilterMenuContent: FC<AutocompleteFilterMenuContentProps>;
+
+interface BackHeaderProps {
+    appName: string;
+    onGoBackClick?: () => void;
+}
+declare const BackHeader: React.FC<BackHeaderProps>;
+
+interface BottomBarProps {
+    className?: string;
+    children?: React.ReactNode;
+    isLoading?: boolean;
+    onRefreshClick?: (() => void) | null;
+}
+declare const BottomBar: ({ className, children, isLoading, onRefreshClick, }: BottomBarProps) => react_jsx_runtime.JSX.Element;
+
+interface BoxButtonProps {
+    label?: any;
+    onClick?: any;
+    main?: any;
+    extra?: any;
+    borderColor?: any;
+}
+declare const _default$k: React.MemoExoticComponent<(props: BoxButtonProps) => react_jsx_runtime.JSX.Element>;
+
+interface IExtendedButton {
+    buttonType?: 'button' | 'submit';
+    className?: string;
+    color?: 'inherit' | 'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning' | 'default' | 'noOutline' | undefined;
+    copy: string;
+    disabled?: boolean;
+    href?: string;
+    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    subcopy?: string;
+    tooltip?: string;
+    component?: React.ElementType;
+    type?: 'add' | 'apps' | 'childCare' | 'delete' | 'edit' | 'importExport' | 'notes' | 'print' | 'save' | 'upload' | 'refresh' | 'download' | 'publish' | 'compare';
+    variant?: 'contained' | 'outlined' | 'text';
+    copyColor?: string;
+}
+declare const _default$j: React.MemoExoticComponent<({ buttonType, color, disabled, href, tooltip, component, type, className, onClick, copy, subcopy, variant, copyColor, }: IExtendedButton) => react_jsx_runtime.JSX.Element>;
+
+interface IFilledButton {
+    autoFocus?: boolean;
+    className?: string;
+    color?: 'default' | 'error' | 'info' | 'inherit' | 'primary' | 'secondary' | 'success' | 'warning';
+    copy: string;
+    isLoading?: boolean;
+    disabled?: boolean;
+    href?: string;
+    onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
+    type?: 'button' | 'submit';
+    variant?: 'contained' | 'outlined' | 'text';
+}
+declare const _default$i: React__default.MemoExoticComponent<({ autoFocus, className, color, copy, disabled, href, isLoading, onClick, type, variant, }: IFilledButton) => react_jsx_runtime.JSX.Element>;
+
+interface FilledButtonLgProps {
+    classes?: any;
+    disabled?: any;
+    variant?: string;
+    color?: string;
+    copy?: any;
+    handleClick?: any;
+    loading?: boolean;
+    loadingProps?: {
+        color?: 'primary' | 'secondary' | 'inherit';
+        size?: number;
+        style?: string;
+    };
+}
+declare const _default$h: React.MemoExoticComponent<({ classes, disabled, variant, color, copy, handleClick, loading, loadingProps, }: FilledButtonLgProps) => react_jsx_runtime.JSX.Element>;
+
+interface ImageButtonProps {
+    src?: any;
+    onClick?: any;
+    value?: any;
+}
+declare const _default$g: React.MemoExoticComponent<(props: ImageButtonProps) => react_jsx_runtime.JSX.Element>;
+
+interface SquareButtonProps {
+    children: any;
+    disabled?: any;
+    hasContentLeftSide?: any;
+    onClick: any;
+    type: any;
+}
+declare const SquareButton: ({ children, disabled, hasContentLeftSide, onClick, type, }: SquareButtonProps) => react_jsx_runtime.JSX.Element;
+
+interface UploadButtonProps {
+    name?: string;
+    onChange?(...args: any[]): any;
+    onBlur?(...args: any[]): any;
+}
+declare const UploadButton: React.ForwardRefExoticComponent<UploadButtonProps & React.RefAttributes<HTMLElement>>;
+
+interface OutlinedButtonProps {
+    className?: any;
+    color?: any;
+    copy: any;
+    disabled?: any;
+    href?: any;
+    isLoading?: any;
+    onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
+    startIcon?: any;
+    style?: any;
+    subcopy?: any;
+    type?: any;
+}
+declare const _default$f: React__default.MemoExoticComponent<({ className, color, copy, disabled, href, isLoading, onClick, startIcon, style, subcopy, type, }: OutlinedButtonProps) => react_jsx_runtime.JSX.Element>;
+
+interface AButtonProps {
+    classes?: any;
+    variant?: string;
+    color?: string;
+    copy?: any;
+}
+declare const _default$e: React.MemoExoticComponent<({ classes, variant, color, copy }: AButtonProps) => react_jsx_runtime.JSX.Element>;
+
+interface IRoundButton {
+    active?: boolean;
+    children?: string;
+    className?: string;
+    disabled?: boolean;
+    focused?: boolean;
+    icon?: 'add' | 'apps' | 'arrowBack' | 'arrowForward' | 'avocado' | 'backspaceOutlined' | 'banana' | 'block' | 'bulk' | 'callSplit' | 'chevronRight' | 'chevronUp' | 'chevronDown' | 'close' | 'delete' | 'done' | 'edit' | 'email' | 'grape' | 'groupAdd' | 'history' | 'menu' | 'notes' | 'refresh' | 'remove' | 'search' | 'send' | 'strawberry' | 'thumbDown' | 'threeDots' | 'thumbUp' | 'undo' | 'play' | 'snail' | 'bus' | 'spoon' | 'fork' | 'car' | 'knife' | 'bicycle' | 'heart' | 'airplane' | 'threeDots' | 'swapHoriz';
+    iconColor?: 'inherit' | 'disabled' | 'primary' | 'secondary' | 'action' | 'error';
+    isContrast?: boolean;
+    isTableButton?: boolean;
+    noStrokes?: boolean;
+    onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
+    size?: 'small' | 'medium' | 'large' | 'double';
+    tooltip?: string;
+    variant?: 'default' | 'defaultPrimary' | 'defaultError' | 'filled' | 'primary' | 'secondary';
+    testID?: string;
+}
+/**
+ * A Rounded button component that is abstracted from MUI Fab component.
+ * Can render an icon or a single character.
+ * https://v4.mui.com/api/fab/#fab-api.
+ */
+declare const RoundButton: ({ active, children, className, disabled, focused, icon, iconColor, isContrast, isTableButton, noStrokes, onClick, size, tooltip, variant, testID, }: IRoundButton) => react_jsx_runtime.JSX.Element;
+
+declare const _default$d: React.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+interface ActionButtonProps {
+    app?: any;
+}
+declare function ActionButton(props: ActionButtonProps): react_jsx_runtime.JSX.Element;
+
+type CheckboxFilterMenuContentProps = {
+    columnId: string;
+    labelFieldName: string;
+    isLoading?: boolean;
+    selectedFilterOptions: HeaderFilterOptions;
+    filterOptions: HeaderFilterOptions;
+    maxHeight?: number;
+    width?: number;
+    shouldShowCheckOnFilter?: TableDesktopProps['shouldShowCheckOnFilter'];
+    onSelectAllChange: (checked: boolean) => void;
+    onFilterOptionChange: (option: string | HeaderFilterObject) => void;
+    onApplyFiltersClick: (shouldSave: boolean) => void;
+};
+declare const CheckboxFilterMenuContent: FC<CheckboxFilterMenuContentProps>;
+
+type ClearFiltersConfirmationDialogProps = {
+    isOpen: boolean;
+    clearFiltersMode: 'unsaved' | 'saved';
+    hasAnyUnsavedFilters: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    onChangeClearFiltersMode: (mode: 'unsaved' | 'saved') => void;
+};
+declare const ClearFiltersConfirmationDialog: FC<ClearFiltersConfirmationDialogProps>;
+
+interface ICompanyLogo {
+    size: 'small' | 'medium';
+    color: 'light' | 'dark';
+    imageLogoDarkSmall: string;
+    imageLogoLightSmall: string;
+}
+declare const CompanyLogo: ({ size, color, imageLogoDarkSmall, imageLogoLightSmall, }: ICompanyLogo) => react_jsx_runtime.JSX.Element;
+
+interface ConfirmationDialogProps {
+    ctaText?: string;
+    hideCancel?: boolean;
+    isLoading?: boolean;
+    hideConfirm?: boolean;
+    closeModal: () => void;
+    content: string | string[] | React.JSX.Element;
+    cancelCopy?: string;
+    isOpen: boolean;
+    onConfirm?: () => void;
+    title: string;
+    disableContentPadding?: boolean;
+}
+declare const ConfirmationDialog: {
+    ({ ctaText, hideCancel, isLoading, hideConfirm, closeModal, content, cancelCopy, isOpen, onConfirm, title, disableContentPadding, }: ConfirmationDialogProps): react_jsx_runtime.JSX.Element;
+    defaultProps: {
+        ctaText: string;
+        hideCancel: boolean;
+        hideConfirm: boolean;
+        cancelCopy: string;
+        isLoading: boolean;
+    };
+};
+
+interface ControlledCheckboxProps {
+    name: string;
+    label: string;
+    id: string;
+    control: Control<any, any>;
+    className?: string;
+    tooltipDescription?: string;
+    'data-testid'?: string;
+    color?: 'primary' | 'secondary' | 'default';
+    handleChange: (checked: boolean, field: ControllerRenderProps<any, string>) => void;
+    disabled?: boolean;
+}
+declare const ControlledCheckbox: React.FC<ControlledCheckboxProps>;
+
+interface ControlledNumberInputProps {
+    /**
+     * control from react-hook-form
+     * */
+    control: Control<any>;
+    /**
+     * name in the form data
+     * */
+    name: string;
+    /**
+     * label name to be shown in the component
+     * */
+    label: string;
+    /**
+     * mininum number allowed
+     * */
+    min?: number;
+    /**
+     * maximum number allowed
+     * */
+    max?: number;
+    /**
+     * step to change the number
+     * */
+    step?: number;
+    /**
+     * optional error message
+     * */
+    error?: string;
+    /**
+     * should shrink the label name
+     * */
+    shrink?: boolean;
+    /**
+     * opcional className to customize the component
+     * */
+    className?: string;
+}
+declare const ControlledNumberInput: ({ name, control, label, min, max, step, error, shrink, className, }: ControlledNumberInputProps) => react_jsx_runtime.JSX.Element;
+
+interface ControlledNumericFieldProps {
+    control: Control<any>;
+    label: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    fullWidth?: boolean;
+    margin?: 'dense' | 'normal' | 'none';
+    helperText?: string;
+    variant?: 'standard' | 'outlined' | 'filled';
+    onChange?: (field: ControllerRenderProps<any, string>, value: number | string) => void;
+    onArrowClick?: (field: ControllerRenderProps<any, string>, value: number | string) => void;
+    onBlur?: (field: ControllerRenderProps<any, string>, value: number | string, fieldState: ControllerFieldState) => void;
+    className?: string;
+    fieldName: string;
+    'data-testid'?: string;
+}
+declare const ControlledNumericField: React.FC<ControlledNumericFieldProps>;
+
+interface ControlledSelectWithArrayProps {
+    /**
+     * control from react-hook-form
+     * */
+    control: Control<any>;
+    /**
+     * name in the form data
+     * */
+    name: string;
+    /**
+     * label name to be shown in the component
+     * */
+    label: string;
+    /**
+     * options to be rendered in the dropbown
+     * */
+    options?: (string | number)[];
+    /**
+     * optional error message
+     * */
+    error?: string;
+    /**
+     * optional onChange event
+     * */
+    onChange?: (value: any) => void;
+    /**
+     * opcional className to customize the component
+     * */
+    className?: string;
+    /**
+     * opcional function to revalidate the form when changing the dropdown value ( trigger function )
+     * */
+    revalidateFormFunction?: UseFormTrigger<any>;
+}
+declare const ControlledSelectWithArray: ({ name, control, label, options, error, onChange, className, revalidateFormFunction, }: ControlledSelectWithArrayProps) => react_jsx_runtime.JSX.Element;
+
+interface ControlledSelectWithObjectProps {
+    /**
+     * control from react-hook-form
+     * */
+    control: Control<any>;
+    /**
+     * name in the form data
+     * */
+    name: string;
+    /**
+     * label name to be shown in the component
+     * */
+    label: string;
+    /**
+     * options to be rendered in the dropbown
+     * */
+    options?: {
+        value: string | number;
+        label: string;
+    }[];
+    /**
+     * optional error message
+     * */
+    error?: string;
+    /**
+     * optional onChange event
+     * */
+    onChange?: (value: any) => void;
+    /**
+     * opcional className to customize the component
+     * */
+    className?: string;
+    /**
+     * opcional boolean to disable the dropdown option (based on the options.value)
+     * */
+    listToDisableFromOptions?: Array<any>;
+    /**
+     * opcional function to revalidate the form when changing the dropdown value ( trigger function )
+     * */
+    revalidateFormFunction?: UseFormTrigger<any>;
+}
+declare const ControlledSelectWithObject: ({ name, control, label, options, error, onChange, className, listToDisableFromOptions, revalidateFormFunction, }: ControlledSelectWithObjectProps) => react_jsx_runtime.JSX.Element;
+
+interface ControlledValidTextInputBaseProps {
+    label: string;
+    fieldName: string;
+    helperText?: string;
+    disabled?: boolean;
+    variant?: 'standard' | 'outlined' | 'filled';
+    className?: string;
+    sx?: BoxProps['sx'];
+    maxLength?: number;
+    'data-testid'?: string;
+    form: UseFormReturn<any>;
+}
+/** Ensure AT MOST ONE of 'updateCustomerData' or 'customHandleBlurValidationAndSubmit' can be provided. */
+type ControlledValidTextInputDefaultProps = ControlledValidTextInputBaseProps & {
+    updateCustomerData?: UseMutateAsyncFunction<any, unknown, any, unknown>;
+    customHandleBlurValidationAndSubmit?: never;
+};
+type ControlledValidTextInputCustomProps = ControlledValidTextInputBaseProps & {
+    updateCustomerData?: never;
+    customHandleBlurValidationAndSubmit?: (controlledField: ControllerRenderProps<FieldValues, string>, isDirty: boolean) => void;
+};
+type ControlledValidTextInputProps = ControlledValidTextInputDefaultProps | ControlledValidTextInputCustomProps;
+declare const ControlledValidTextInput: React.FC<ControlledValidTextInputProps>;
+
+interface DataGridProps {
+    isLoading?: boolean;
+    children?: React.ReactElement;
+    height: string;
+    sortField?: string;
+    sortDir?: string;
+    columns: any;
+    rows: any;
+    handleCellEdition?: any;
+}
+declare const DataGrid: ({ columns, rows, handleCellEdition, sortField, sortDir, isLoading, height, children, }: DataGridProps) => react_jsx_runtime.JSX.Element;
+
+interface DateProps {
+    datetime: string | Date;
+    format?: string;
+}
+declare const Date: React.FC<DateProps>;
+
+interface IDeleteSubstitutionDialogContent {
+    closeDialog: () => void;
+    deleteSubstitution: () => void;
+    substitutionName: string;
+}
+declare const _default$c: React.MemoExoticComponent<({ closeDialog, substitutionName, deleteSubstitution, }: IDeleteSubstitutionDialogContent) => react_jsx_runtime.JSX.Element>;
+
+interface IDeleteUserDialogContent {
+    closeDialog: () => void;
+    deleteUser: () => void;
+    userName: string;
+}
+declare const _default$b: React.MemoExoticComponent<({ closeDialog, userName, deleteUser, }: IDeleteUserDialogContent) => react_jsx_runtime.JSX.Element>;
+
+type BaseDeliveryInstructionsFormFields = {
+    alarm_code?: string | null;
+    door_code?: string | null;
+    keys_code?: string | null;
+    preferred_delivery_window?: string | null;
+    invoice_signature_required?: boolean;
+    delivery_instructions?: string | null;
+};
+type DeliveryInstructionsFormFieldsProps<T extends BaseDeliveryInstructionsFormFields & FieldValues> = {
+    form: UseFormReturn<T>;
+    onTextFieldsBlur?: (fieldName: Path<T>) => void;
+    onInvoiceSignatureCheckboxChange?: (checked: boolean) => void;
+};
+declare const DeliveryInstructionsFormFields: <T extends BaseDeliveryInstructionsFormFields & FieldValues>({ form, onTextFieldsBlur, onInvoiceSignatureCheckboxChange, }: DeliveryInstructionsFormFieldsProps<T>) => react_jsx_runtime.JSX.Element;
+
+type DynamicOverflowTooltipProps = {
+    arrow?: boolean;
+    maxWidth?: number | string;
+    children: ReactElement | string | number | null;
+    tooltipDescription: string;
+};
+declare const DynamicOverflowTooltip: FC<DynamicOverflowTooltipProps>;
+
+interface FileCardProps {
+    document: string;
+}
+declare const FileCard: ({ document }: FileCardProps) => react_jsx_runtime.JSX.Element;
+
+interface FilledLabelProps {
+    color?: string;
+    copy?: any;
+}
+declare const _default$a: React.MemoExoticComponent<(props: FilledLabelProps) => react_jsx_runtime.JSX.Element>;
+
+type IFilterGroupSelector = {
+    name?: string;
+    categoryIdentification?: string;
+    selectedOptions: string[];
+    setSelectedOptions: React.Dispatch<React.SetStateAction<string[]>>;
+    handleClickOnApply: () => void;
+    optionsList?: {
+        category: string;
+        options: string[];
+    }[];
+};
+declare const FilterGroupSelector: ({ name, categoryIdentification, selectedOptions, setSelectedOptions, handleClickOnApply, optionsList, }: IFilterGroupSelector) => react_jsx_runtime.JSX.Element;
+
+type IFilterSimpleSelector = {
+    name?: string;
+    options?: string[];
+    selectedOptions: string[];
+    setSelectedOptions: React.Dispatch<React.SetStateAction<string[]>>;
+    handleClickOnApply: () => void;
+};
+declare const FilterSimpleSelector: ({ name, options, selectedOptions, setSelectedOptions, handleClickOnApply, }: IFilterSimpleSelector) => react_jsx_runtime.JSX.Element;
+
+type FilterOptionsCheckboxesProps = {
+    columnId: string;
+    labelFieldName: string;
+    maxWidth?: number;
+    filterOptions: HeaderFilterOptions;
+    selectedFilterOptions: HeaderFilterOptions;
+    onFilterOptionChange: (option: string | HeaderFilterObject) => void;
+    shouldShowCheckOnFilter?: TableDesktopProps['shouldShowCheckOnFilter'];
+};
+declare const FilterOptionsCheckboxes: FC<FilterOptionsCheckboxesProps>;
+
+interface FixedFooterProps {
+    children: React.ReactNode;
+    justifyContent?: string;
+}
+declare const _default$9: React.MemoExoticComponent<({ justifyContent, children }: FixedFooterProps) => react_jsx_runtime.JSX.Element>;
+
+interface HeaderProps {
+    appName: any;
+    children?: any;
+    wrappedHeader?: any;
+}
+declare const Header: ({ appName, children, wrappedHeader, }: HeaderProps) => react_jsx_runtime.JSX.Element;
+
+declare const icons: {
+    SvgSamsaraLogo: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconHome: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconNotification: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconPhone: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconAccount: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconOrders: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconPriceList: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconSpecialPrice: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconBuying: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconContentManagement: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconProducts: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconStock: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconSupplier: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconSupplierPrices: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconGoodsin: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconVkc: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconLocation: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconScales: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconQc: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconRetail: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconRuns: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconAccounts: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconReports: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconSetting: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconLogin: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgBallsLogo: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconAvocado: () => react_jsx_runtime.JSX.Element;
+    SvgIconBanana: () => react_jsx_runtime.JSX.Element;
+    SvgIconGrape: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconStrawberry: () => react_jsx_runtime.JSX.Element;
+    SvgIconPromoCode: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconOpsMetrics: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconSearchCategories: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconImport: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconSnail: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgEmptyGlassIcon: (props: any) => react_jsx_runtime.JSX.Element;
+    SvgIconUserManagement: () => react_jsx_runtime.JSX.Element;
+    SvgIconTableEdit: (props: React.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
+};
+
+type LabeledValueListProps = {
+    label: string;
+    values: (string | number)[];
+};
+declare const LabeledValueList: FC<LabeledValueListProps>;
+
+interface VirtualizedListProps {
+    headers?: any;
+    items?: any;
+    renderItem?: any;
+}
+declare function VirtualizedList(props: VirtualizedListProps): react_jsx_runtime.JSX.Element;
+
+interface ILoading {
+    isLoading: boolean;
+}
+declare const Loading: ({ isLoading }: ILoading) => react_jsx_runtime.JSX.Element;
+
+interface ILocationsSectionInfo {
+    principalLocation: string;
+    secondaryLocation?: string[];
+    isPicking?: boolean;
+    isStock?: boolean;
+}
+declare const LocationsSectionInfo: ({ principalLocation, secondaryLocation, isPicking, isStock, }: ILocationsSectionInfo) => react_jsx_runtime.JSX.Element;
+
+interface NotesProps {
+    initialNotes?: any;
+    isDisabled?: any;
+    isEditable?: any;
+    isLoading?: any;
+    maxLength?: any;
+    onBlur?: any;
+    onChange?: any;
+    onClearNotes?: any;
+}
+declare const Notes: ({ initialNotes, isDisabled, isEditable, isLoading, maxLength, onBlur, onChange, onClearNotes, }: NotesProps) => react_jsx_runtime.JSX.Element;
+
+interface NumpadProps {
+    handleClick: any;
+    handleUndo: any;
+}
+declare const Numpad: ({ handleClick, handleUndo }: NumpadProps) => react_jsx_runtime.JSX.Element;
+
+interface NumpadInputProps {
+    handleNextClick?(...args: any[]): any;
+    inputLabel?: string;
+    children?: any;
+}
+declare const _default$8: React.MemoExoticComponent<(props: NumpadInputProps) => react_jsx_runtime.JSX.Element>;
+
+interface NumpadPlusProps {
+    handleClick: any;
+    handleUndo: any;
+}
+declare const NumpadPlus: ({ handleClick, handleUndo }: NumpadPlusProps) => react_jsx_runtime.JSX.Element;
+
+interface PaginationForTableProps {
+    appliedFilters?: any;
+    className?: any;
+    page?: any;
+    pagination?: any;
+    position?: any;
+    style?: any;
+    updateFilters: any;
+}
+declare const PaginationForTable: ({ appliedFilters, className, page, pagination, position, style, updateFilters, }: PaginationForTableProps) => react_jsx_runtime.JSX.Element;
+
+interface PhoneInputProps {
+    value?: string | null;
+    onChange?: (phone: string | null) => void;
+    placeholder?: string;
+    sx?: BoxProps['sx'];
+    className?: string;
+    label?: string;
+    error?: boolean;
+}
+declare const PhoneInput: React__default.FC<PhoneInputProps>;
+
+interface PlusMinusInputProps {
+    allowNegative?: any;
+    buttonsPosition?: any;
+    disabled?: any;
+    initialValue?: any;
+    inputSize?: any;
+    label: any;
+    updateInputValue: any;
+}
+declare const PlusMinusInput: ({ allowNegative, buttonsPosition, disabled, initialValue, inputSize, label, updateInputValue, }: PlusMinusInputProps) => react_jsx_runtime.JSX.Element;
+
+interface PBustProps {
+    buttonData?: any;
+    classes?: any;
+    locationData?: any;
+    locationId?: any;
+    primaryData?: any;
+    product?: any;
+    secondaryData?: any;
+    size?: any;
+    LocationHistoryDialog: ComponentType<any>;
+}
+declare const ProductBust: ({ classes, size, product, locationData, primaryData, secondaryData, buttonData, locationId, LocationHistoryDialog, }: PBustProps) => react_jsx_runtime.JSX.Element;
+
+interface PImageProps {
+    classes?: any;
+    image?: any;
+    size?: any;
+    status?: any;
+}
+declare const ProductImage: ({ classes, image, size, status, }: PImageProps) => react_jsx_runtime.JSX.Element;
+
+interface IRenderAvatar {
+    active?: boolean;
+}
+declare const RenderAvatar: ({ active }: IRenderAvatar) => react_jsx_runtime.JSX.Element;
+
+interface IRenderContentList {
+    items: string[];
+    warningItems?: string[] | null;
+    warningMessage?: string;
+    activeSection: string;
+}
+declare const RenderContentList: ({ items, activeSection, warningItems, warningMessage, }: IRenderContentList) => react_jsx_runtime.JSX.Element;
+
+type ProductSize = 'small' | 'medium' | 'large';
+interface Column {
+    title: string;
+    value: string | React.ReactNode;
+}
+interface Product {
+    image: string;
+    name: string;
+    status?: string;
+}
+interface RowProductCardProps {
+    /**
+     * Possible actions or buttons that the card can have
+     */
+    children?: React.ReactNode;
+    /**
+     * Details about the product
+     */
+    columns?: Column[];
+    /**
+     * Where is the product location
+     */
+    location?: string;
+    /**
+     * Product information
+     */
+    product: Product;
+    /**
+     * Size of the product image
+     */
+    size?: ProductSize;
+}
+/**
+ * A card on row format that can display informations about a product
+ * It can be very detailed or lean
+ */
+declare const RowProductCard: ({ children, columns, location, product, size, }: RowProductCardProps) => react_jsx_runtime.JSX.Element;
+
+interface ScrollableDialogProps {
+    body: ReactNode;
+    footer?: ReactNode;
+    header?: ReactNode;
+    isOpen: boolean;
+    title: string;
+}
+declare const ScrollableDialog: ({ body, footer, header, isOpen, title, }: ScrollableDialogProps) => react_jsx_runtime.JSX.Element;
+
+interface ISearchAndFilterHeaderProps {
+    appName: string;
+    enterPressedInSearch?: () => void;
+    extraButton?: React.ReactNode;
+    filtersComponent?: React.ReactNode;
+    appliedFiltersComponent?: React.ReactNode;
+    filterClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    showFilters: boolean;
+    updateFilters?: (filters: any) => void;
+    searchValue?: string;
+}
+declare const SearchAndFilterHeader: ({ appName, enterPressedInSearch, extraButton, filterClick, showFilters, updateFilters, filtersComponent, appliedFiltersComponent, searchValue, }: ISearchAndFilterHeaderProps) => react_jsx_runtime.JSX.Element;
+
+interface SearchAndFilterHeaderForTableProps {
+    appName: string;
+    button?: React.ReactNode;
+    copy?: string;
+    enterPressedInSearch?(...args: any[]): any;
+    isOpen?: boolean;
+    onFilterButtonClick?(...args: any[]): any;
+    searchedValue?: string;
+    showFilterButton?: boolean;
+    updateSearch?(...args: any[]): any;
+}
+declare const _default$7: React.MemoExoticComponent<(props: SearchAndFilterHeaderForTableProps) => react_jsx_runtime.JSX.Element>;
+
+type SearchFieldDebouncedProps = {
+    onSearch?: (value: string) => void;
+    value?: string;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: React__default.KeyboardEvent<HTMLInputElement>) => void;
+    variant?: 'outlined' | 'filled' | 'standard';
+    hideSearchIcon?: boolean;
+    initialValue?: string;
+    debounceDelay?: number;
+    minCharacters?: number;
+    sx?: SxProps<Theme>;
+    width?: number;
+    inputProps?: {
+        sx: SxProps<Theme>;
+    };
+};
+declare const SearchFieldDebounced: React__default.FC<SearchFieldDebouncedProps>;
+
+type SearchHeaderProps = {
+    renderButton?: ReactNode;
+    renderExtraAction?: ReactNode;
+    children?: ReactNode;
+    onSearch?: (value: string) => void;
+    value?: string;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: React__default.KeyboardEvent<HTMLInputElement>) => void;
+    width?: number;
+};
+declare const SearchHeader: ({ renderButton, renderExtraAction, children, onSearch, value, onChange, onKeyDown, width, }: SearchHeaderProps) => react_jsx_runtime.JSX.Element;
+
+interface ISearchWithFiltersProps {
+    enterPressedInSearch?: () => void;
+    filterClick?: React.MouseEventHandler<HTMLButtonElement>;
+    handleClick?: () => void;
+    searchValue?: string;
+    showFilters: boolean;
+    updateFilters?: (filters: {
+        search: string;
+    }) => void;
+    disabled?: boolean;
+}
+declare const _default$6: React.MemoExoticComponent<({ enterPressedInSearch, filterClick, handleClick, searchValue, showFilters, updateFilters, disabled, }: ISearchWithFiltersProps) => react_jsx_runtime.JSX.Element>;
+
+interface SearchWithFiltersForTableProps {
+    onFilterButtonClick?(...args: any[]): any;
+    isOpen?: boolean;
+    updateSearch?(...args: any[]): any;
+    enterPressedInSearch?(...args: any[]): any;
+    showFilterButton?: boolean;
+    searchedValue?: string;
+}
+declare const _default$5: React.MemoExoticComponent<(props: SearchWithFiltersForTableProps) => react_jsx_runtime.JSX.Element>;
+
+interface SectionNameProps {
+    name: string;
+    tooltipDescription?: string;
+    sectionId?: string;
+    buttonText?: string;
+    buttonType?: 'add' | 'apps' | 'childCare' | 'delete' | 'edit' | 'importExport' | 'notes' | 'print' | 'save' | 'upload' | 'refresh' | 'download' | 'publish';
+    handleButtonClick?: () => void;
+    buttonDisabled?: boolean;
+    openHistoryLog?: () => void;
+}
+declare const SectionName: ({ name, tooltipDescription, sectionId, handleButtonClick, buttonText, buttonType, buttonDisabled, openHistoryLog, }: SectionNameProps) => react_jsx_runtime.JSX.Element;
+
+type Option = {
+    value?: string | number;
+    label?: string;
+    disabled?: boolean;
+};
+interface SmartSelectProps {
+    value?: string | number | null;
+    defaultOption?: Option;
+    options?: Option[];
+    refetch?: () => void;
+    isFetching?: boolean;
+    onChange: (selectedOption: Option) => void;
+    inputLabel?: string;
+    variant?: SelectProps['variant'];
+    size?: SelectProps['size'];
+    error?: boolean;
+    helperText?: string;
+    disabled?: boolean;
+    allowBlankOption?: boolean;
+    'data-testid'?: string;
+    emptyMessage?: string;
+    menuProps?: Partial<MenuProps>;
+}
+declare const SmartSelect: React.ForwardRefExoticComponent<SmartSelectProps & React.RefAttributes<unknown>>;
+
+type SmartMultipleSelectProps = {
+    inputLabel?: string;
+    variant?: SelectProps['variant'];
+    size?: SelectProps['size'];
+    error?: boolean;
+    values?: Option[];
+    defaultValues?: Option[];
+    onOpen?: () => void;
+    onChange?: (values: Option[]) => void;
+    onClose?: (values: Option[]) => void;
+    menuOptions?: Option[];
+    isLoading?: boolean;
+    disabled?: boolean;
+    emptyMessage?: string;
+    helperText?: string;
+    menuProps?: Partial<MenuProps>;
+};
+declare const SmartMultipleSelect: FC<SmartMultipleSelectProps>;
+
+interface SquareLabelProps {
+    color?: string;
+    copy?: any;
+}
+declare const _default$4: React.MemoExoticComponent<({ color, copy }: SquareLabelProps) => react_jsx_runtime.JSX.Element>;
+
+interface LSwitchProps {
+    classes?: any;
+    checked?: any;
+    labelOn?: any;
+    labelOff?: any;
+    handleChange?: any;
+    disabled: any;
+}
+declare const _default$3: React.MemoExoticComponent<({ checked, labelOn, labelOff, handleChange, classes, disabled, }: LSwitchProps) => react_jsx_runtime.JSX.Element>;
+
+type SmartTableHeaderFilterMenuProps = {
+    headCell: HeadCell;
+    headerFilters: HeaderFilters;
+    numActiveFilters: number;
+    shouldShowCheckOnFilter?: TableDesktopProps['shouldShowCheckOnFilter'];
+    onApplyFilters?: TableDesktopProps['onApplyFilters'];
+};
+declare const SmartTableHeaderFilterMenu: ({ headCell, numActiveFilters, headerFilters, shouldShowCheckOnFilter, onApplyFilters, }: SmartTableHeaderFilterMenuProps) => react_jsx_runtime.JSX.Element;
+
+type SmartTableHeaderProps = {
+    order: Order;
+    orderBy: string;
+    headCells: HeadCell[];
+    numSelectedRows: number;
+    numRows: number;
+    enableCheckboxSelection?: boolean;
+    headerFilters: HeaderFilters;
+    onRequestSort: (event: MouseEvent<unknown>, property: string) => void;
+    onSelectAllClick: (event: ChangeEvent<HTMLInputElement>) => void;
+    onApplyFilters?: TableDesktopProps['onApplyFilters'];
+    shouldShowCheckOnFilter?: TableDesktopProps['shouldShowCheckOnFilter'];
+};
+declare const SmartTableHeader: React.MemoExoticComponent<({ order, orderBy, headCells, numSelectedRows, numRows, enableCheckboxSelection, headerFilters, onRequestSort, onSelectAllClick, onApplyFilters, shouldShowCheckOnFilter, }: SmartTableHeaderProps) => react_jsx_runtime.JSX.Element>;
+
+interface TableProps {
+    headCells?: {
+        id?: string;
+        label?: string;
+        numeric?: boolean;
+        disablePadding?: boolean;
+    }[];
+    data?: {}[];
+    RenderItem?: React.ComponentType<any> | null;
+    isLoading?: boolean;
+    updateSort?(...args: any[]): any;
+    page?: number;
+    rowsPerPage?: number;
+    onRowClick?(...args: any[]): any;
+    serverRendered?: boolean;
+    appliedFilters?: any;
+    doNotCalculateRows?: any;
+}
+declare const Table: ({ appliedFilters, data, doNotCalculateRows, headCells, isLoading, onRowClick, page, RenderItem, rowsPerPage: defaultRowsPerPage, serverRendered, updateSort, }: TableProps) => react_jsx_runtime.JSX.Element;
+
+type TableDesktopEditableFieldProps = {
+    headCell: HeadCell;
+    editInitialValue?: any;
+    rowId?: RowId;
+    disabled?: boolean;
+    showCheckboxLabel?: boolean;
+    variant?: 'standard' | 'outlined' | 'filled';
+    size?: 'medium' | 'small';
+    onUpdateEditableCell: HeadCell['onUpdateEditableCell'];
+};
+declare const TableDesktopEditableField: FC<TableDesktopEditableFieldProps>;
+
+type ReadOnlyValue = string | number | boolean | ReactNode;
+type TableDesktopCellProps = {
+    editInitialValue: any;
+    rowId: RowId;
+    enableEditMode: boolean;
+    disabled?: boolean;
+    readOnlyValue: ReadOnlyValue;
+    headCell: HeadCell;
+    onCellClick?: (event: MouseEvent<HTMLTableCellElement>, isEditMode: boolean) => void;
+};
+declare const TableDesktopCell: FC<TableDesktopCellProps>;
+
+interface ITableEmptyResult {
+    colSpan: number;
+    showClearFilterButton?: boolean;
+    handleClickOnClearFiltersButton?: () => void;
+}
+declare const TableEmptyResult: ({ colSpan, showClearFilterButton, handleClickOnClearFiltersButton, }: ITableEmptyResult) => react_jsx_runtime.JSX.Element;
+
+interface TableLoadingProps {
+    rowsPerPage?: number;
+    rowHeight?: number;
+}
+declare const TableLoading: React__default.FC<TableLoadingProps>;
+
+interface TableHeaderProps {
+    cells: any;
+    onSort?: any;
+}
+declare const _default$2: React.MemoExoticComponent<({ cells, onSort }: TableHeaderProps) => react_jsx_runtime.JSX.Element>;
+
+interface TextDividerProps {
+    title: string;
+    icon?: React.ElementType;
+    onClick?: () => void;
+    color?: string;
+    iconPosition?: 'left' | 'right';
+    titleWeight?: '400' | '500' | '600' | '700' | '800' | '900';
+}
+declare const TextDivider: React.FC<TextDividerProps>;
+
+type ThemedDateRangePickerProps = DateRangePickerShape & {
+    className?: string;
+};
+/**
+ * DateRangePicker component with dark mode theming support.
+ * Props are forwarded directly to the underlying DateRangePicker.
+ */
+declare const ThemedDateRangePicker: ({ className, ...props }: ThemedDateRangePickerProps) => react_jsx_runtime.JSX.Element;
+
+type Props = {
+    imageLogoDarkSmall: string;
+    imageLogoLightSmall: string;
+    handleOpen: () => void;
+    LeftDrawer: ReactNode;
+    leftSection?: ReactNode;
+    rightSection?: ReactNode;
+    isAuthenticated?: boolean;
+};
+declare const _default$1: React.MemoExoticComponent<({ imageLogoDarkSmall, imageLogoLightSmall, handleOpen, LeftDrawer, leftSection, rightSection, isAuthenticated, }: Props) => react_jsx_runtime.JSX.Element>;
+
+type IToastMessage = {
+    toastType: 'success' | 'info' | 'warning' | 'error';
+    toastMessage: string;
+    open: boolean;
+    onClose: () => void;
+};
+/**
+ *@param toastType 'success' | 'info' | 'warning' | 'error';.
+ *@param toastMessage  Value to be displayed on screen;.
+ *@param open Boolean to open the toast;.
+ *@param updateToast Reducer function to update the reducer value
+ */
+declare const ToastMessage: ({ toastType, toastMessage, open, onClose, }: IToastMessage) => react_jsx_runtime.JSX.Element;
+
+interface ITwoButtonDialogProps {
+    confirmButton: () => void;
+    cancelButton?: () => void;
+    dialogLoading?: boolean;
+    title: string;
+    subtitle1?: string | React.ReactNode;
+    subtitle2?: string | React.ReactNode;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    confirmLabel?: string;
+    cancelLabel?: string;
+}
+declare const TwoButtonDialog: FC<ITwoButtonDialogProps>;
+
+type UserBustProps = {
+    user: {
+        profile_picture: string;
+        first_name: string;
+        last_name: string;
+        username: string;
+    };
+    avatarProps: {
+        height: number;
+        width: number;
+    };
+    typographyProps: {
+        name?: {
+            variant: ComponentProps<typeof Typography>['variant'];
+            component: string;
+        };
+        username?: {
+            variant: ComponentProps<typeof Typography>['variant'];
+            component: string;
+        };
+    };
+};
+declare const _default: React.MemoExoticComponent<({ user, avatarProps, typographyProps }: UserBustProps) => react_jsx_runtime.JSX.Element>;
+
+type Tag = {
+    id: number;
+    tag: string;
+};
+type AutocompleteType<T extends Tag> = AutocompleteProps<T, false, false, false>;
+interface HashtagInputProps extends Omit<AutocompleteType<any>, 'options' | 'renderInput'> {
+    label?: TextFieldProps['label'];
+    placeholder?: TextFieldProps['placeholder'];
+    variant?: TextFieldProps['variant'];
+    error?: TextFieldProps['error'];
+    helperText?: TextFieldProps['helperText'];
+    autoFocus?: TextFieldProps['autoFocus'];
+    disableOnBlurCreation?: boolean;
+    onCreateTag?: (tagName?: string) => void;
+    onDeleteTag?: (tag?: Tag | string) => void;
+}
+declare const HashtagInput: ({ label, placeholder, variant, error, helperText, onCreateTag, onDeleteTag, autoFocus, disableOnBlurCreation, onBlur, ...props }: HashtagInputProps) => react_jsx_runtime.JSX.Element;
+
+declare const SvgIconCompare: (props: SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
+
+declare const SvgIconChart: (props: SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;
+
+export { ActiveFiltersIconButton, AddressFormFields, type AddressOption, AlertDialog, AlertDialogFullScreen, AppLabel, AppliedTableFiltersDisplay, AutocompleteFilterMenuContent, BackHeader, BottomBar, _default$k as BoxButton, CheckboxFilterMenuContent, ClearFiltersConfirmationDialog, CompanyLogo, ConfirmationDialog, ControlledCheckbox, ControlledNumberInput, ControlledNumericField, ControlledSelectWithArray, ControlledSelectWithObject, ControlledValidTextInput, DataGrid, Date, _default$c as DeleteSubstitutionDialogContent, _default$b as DeleteUserDialogContent, DeliveryInstructionsFormFields, DynamicOverflowTooltip, _default$j as ExtendedButton, FileCard, _default$i as FilledButton, _default$h as FilledButtonLg, _default$a as FilledLabel, FilterGroupSelector, FilterOptionsCheckboxes, FilterSimpleSelector, _default$9 as FixedFooter, GooglePlacesAddressAutocomplete, HashtagInput, HeadCell, Header, HeaderFilterObject, HeaderFilterOptions, HeaderFilters, SvgIconChart as IconChart, SvgIconCompare as IconCompare, _default$g as ImageButton, LabeledValueList, VirtualizedList as List, Loading, LocationsSectionInfo, Notes, Numpad, _default$8 as NumpadInput, NumpadPlus, type Option, Order, _default$f as OutlinedButton, _default$e as OutlinedButtonLg, PaginationForTable as Pagination, PhoneInput, _default$d as Pin, ActionButton as PinnedApp, PlusMinusInput, ProductBust, ProductImage, RenderAvatar, RenderContentList, RoundButton, RowId, RowProductCard, ScrollableDialog, SearchAndFilterHeader, _default$7 as SearchAndFilterHeaderForTable, SearchFieldDebounced, SearchHeader, _default$6 as SearchWithFilters, _default$5 as SearchWithFiltersForTable, SectionName, SmartMultipleSelect, SmartSelect, SmartTableHeader, SmartTableHeaderFilterMenu, SquareButton, _default$4 as SquareLabel, _default$3 as Switch, Table, TableDesktopCell, TableDesktopEditableField, TableEmptyResult, _default$2 as TableHeader, TableLoading, TextDivider, _default$1 as TheToolbar, ThemedDateRangePicker, ToastMessage, TwoButtonDialog, UploadButton, _default as UserBust, icons };