@university-ecosystem/ui-kit/dist/types.d.ts

University ecosystem ui-kit

import * as react from 'react';
import react__default from 'react';
import * as _emotion_styled from '@emotion/styled';
import * as _emotion_react from '@emotion/react';
import { Theme } from '@emotion/react';
import * as react_slotify from 'react-slotify';

declare const ButtonColor: {
    primary: string;
    contrast: string;
    grey: string;
};
interface ButtonColorValues {
    hover: string;
    base: string;
    clicked: string;
}
declare const ButtonVariants: {
    filled: string;
    secondary: string;
    text: string;
};
declare const ButtonSize: {
    fullWidth: string;
    large: string;
    default: string;
    small: string;
    inherit: string;
};
type ButtonProps = React.ComponentProps<'button'> & {
    variant?: keyof typeof ButtonVariants;
    onlyIcon?: boolean;
    icon?: React.ReactNode;
    size?: keyof typeof ButtonSize;
    isLoading?: boolean;
    color?: keyof typeof ButtonColor;
};

declare const Button: react__default.FC<ButtonProps>;

declare const ButtonWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & react.ClassAttributes<HTMLButtonElement> & react.ButtonHTMLAttributes<HTMLButtonElement> & {
    variant?: "filled" | "secondary" | "text" | undefined;
    onlyIcon?: boolean | undefined;
    icon?: react.ReactNode;
    size?: "fullWidth" | "large" | "default" | "small" | "inherit" | undefined;
    isLoading?: boolean | undefined;
    color?: "primary" | "contrast" | "grey" | undefined;
} & {
    buttonColor: ButtonColorValues;
}, react.DetailedHTMLProps<react.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {}>;

declare const ThemeProvider: react__default.FC<{
    children: react__default.ReactNode;
    theme?: Theme;
}>;

declare const ecosystemTheme: Theme;

type InputSize = 'large' | 'default' | 'small' | 'fullwidth';
type InputBaseColor = 'white' | 'grey';
type InputProps = React.ComponentProps<'input'> & {
    errorText?: string;
    variant?: InputSize;
    rightIcon?: React.ReactElement;
    disableClearIcon?: boolean;
    value?: string;
    baseColor?: InputBaseColor;
    label?: string;
    onChange?: (value: string | number) => void;
};

declare const Input: react__default.ForwardRefExoticComponent<Omit<InputProps, "ref"> & react__default.RefAttributes<HTMLInputElement>>;

declare const StyledInputContainer: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledInputWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & Pick<InputProps, "variant" | "errorText" | "baseColor">, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledInput: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, {}>;

declare const TypographyVariants: {
    h1: string;
    h2: string;
    h3: string;
    h4: string;
    h5: string;
    h6: string;
    body1: string;
    body2: string;
};
declare const TypographyColors: {
    error: string;
    primary: string;
    secondary: string;
    base: string;
    description: string;
    inherit: string;
};
interface TypographyProps {
    variant: keyof typeof TypographyVariants;
    color?: keyof typeof TypographyColors;
    textAlign?: string;
    children: React.ReactNode;
    bold?: boolean;
}

declare const Typography: react__default.FC<TypographyProps>;

declare const ColorMap: {
    [x: string]: string;
};

declare const TypographyWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & TypographyProps & {
    textColor: string;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

type CheckboxProps = {
    title?: React.ReactElement | string;
    value: string | number;
    checked: boolean;
    onSelect: (value: string | number) => void;
    disabled?: boolean;
};

declare const Checkbox: react__default.FC<CheckboxProps>;

declare const StyledCheckbox: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const BadgeVariants: {
    filled: string;
    outlined: string;
};
declare const BadgeColor: {
    primary: string;
    contrast: string;
    grey: string;
};
interface BadgeColorValues {
    hover: string;
    base: string;
}
interface BadgeProps {
    leftIcon?: React.ReactElement;
    rightIcon?: React.ReactElement;
    text: string | React.ReactElement;
    variant?: keyof typeof BadgeVariants;
    color?: keyof typeof BadgeColor;
    onClick?: () => void;
}

declare const Badge: react__default.FC<BadgeProps>;

declare const BadgeWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & Pick<BadgeProps, "variant"> & {
    badgeColor: BadgeColorValues;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface PortalProps {
    children: React.ReactElement | React.ReactNode;
    portalId?: string;
}

declare const Portal: react__default.FC<PortalProps>;

interface BaseModalProps {
    isOpen: boolean;
    onClose: () => void;
    children: React.ReactElement | React.ReactNode;
}

declare const BaseModal: react__default.FC<BaseModalProps>;

declare const HeaderSlot: react_slotify.SlotType<object>;

declare const ContentSlot: react_slotify.SlotType<object>;

declare const FooterSlot: react_slotify.SlotType<object>;

interface HeaderProps {
    title: string;
    description?: string;
    children?: React.ReactElement | React.ReactNode;
    onClose: () => void;
}

declare const Header: react__default.FC<HeaderProps>;

declare const StyledModalHeader: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledModalTextWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface FooterProps {
    actions: Array<ButtonProps>;
    children?: React.ReactElement | React.ReactNode;
}

declare const Footer: react__default.FC<FooterProps>;

declare const StyledModalFooter: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface ContentProps {
    children: React.ReactNode | React.ReactElement;
}

declare const Content: react__default.FC<ContentProps>;

declare const StyledModalContent: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface ModalProps extends BaseModalProps {
}

declare const ModalWindow: react__default.FC<ModalProps> & {
    Header: react__default.FC<HeaderProps>;
    Content: react__default.FC<ContentProps>;
    Footer: react__default.FC<FooterProps>;
};

interface NavigationOptionProps {
    icon?: React.ReactElement | React.ReactNode;
    text?: string | React.ReactElement | React.ReactNode;
    link: string;
    selected?: boolean;
    onSelect: (link: string) => void;
}

declare const NavigationOption: react__default.FC<NavigationOptionProps>;

declare const StyledNavOption: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    selected?: boolean | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const NavigationFooter: react__default.FC<{
    children?: react__default.ReactElement | react__default.ReactNode;
}>;

declare const NavigationFooterWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

type OptionProps = Omit<NavigationOptionProps, 'onSelect'>;
interface NavigationProps {
    logo?: string | React.ReactElement | React.ReactNode;
    onSelectOption: (link: string) => void;
    options: Array<OptionProps>;
    footer?: React.ReactElement | React.ReactNode;
    optionsPosition?: string;
}

declare const Navigation: react__default.FC<NavigationProps>;

declare const StyledNavigationWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledLogoWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledOptionsWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    optionsPosition: string;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const LayoutFullWindow: react__default.FC<{
    children: react__default.ReactElement | react__default.ReactNode;
    gridTemplage?: string;
    className?: string;
}>;

declare const StyledFullLayout: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    gridTemplate?: string | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const PageHeaderSlot: react_slotify.SlotType<object>;

interface PageHeaderProps {
    title?: string | React.ReactElement;
    children?: React.ReactElement | React.ReactNode;
    menuButtonColors?: keyof typeof ButtonColor;
    actions?: Array<ButtonProps & {
        onClick?: () => void;
    }>;
}

declare const PageHeader: react__default.FC<PageHeaderProps>;

declare const PageHeaderWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const PageHeaderActions: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const PageContent: react__default.FC<{
    children?: react__default.ReactElement | react__default.ReactNode;
}>;

declare const PageContentWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const PageLayout: react__default.FC<{
    children: react__default.ReactElement | react__default.ReactNode;
}> & {
    Header: react__default.FC<PageHeaderProps>;
    Content: react__default.FC<{
        children?: react__default.ReactNode | react__default.ReactElement<any, string | react__default.JSXElementConstructor<any>>;
    }>;
};

declare const PageLayoutWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface DefaultLayoutProps {
    isLoading: boolean;
    isError: boolean;
    isEmpty: boolean;
    children?: React.ReactNode | React.ReactElement;
}

declare const DefaultLayout: react__default.FC<DefaultLayoutProps>;

declare const DefaultLoadingSlot: react_slotify.SlotType<object>;

declare const DefaultErrorSlot: react_slotify.SlotType<object>;

declare const DefaultEmptySlot: react_slotify.SlotType<object>;

declare const CardHeaderSlot: react_slotify.SlotType<object>;

declare const CardFooterSlot: react_slotify.SlotType<object>;

interface CardHeaderProps {
    title: string | React.ReactElement;
    description?: string | React.ReactElement;
    children?: React.ReactNode | React.ReactElement;
}

declare const CardHeader: react__default.FC<CardHeaderProps>;

declare const StyledCardHeader: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledCardTextWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledCardImageWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const CardContent: react__default.FC<{
    children: react__default.ReactElement | react__default.ReactNode;
}>;

declare const StyledCardContent: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface CardFooterProps {
    actions: Array<ButtonProps>;
    children?: React.ReactElement | React.ReactNode;
}

declare const CardFooter: react__default.FC<CardFooterProps>;

declare const StyledCardFooter: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface CardProps {
    children: React.ReactElement | React.ReactNode;
    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
}

declare const Card: react__default.FC<CardProps> & {
    CardHeader: react__default.FC<CardHeaderProps>;
    CardContent: react__default.FC<{
        children: react__default.ReactNode | react__default.ReactElement<any, string | react__default.JSXElementConstructor<any>>;
    }>;
    CardFooter: react__default.FC<CardFooterProps>;
};

declare const StyledCardWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const Hoverable: react__default.FC<{
    children: react__default.ReactElement | react__default.ReactNode;
}>;

declare const HoverableWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface MenuOptionProps {
    title: string | React.ReactElement | React.ReactNode;
    description?: string;
    icon?: React.ReactElement | React.ReactNode;
    onSelect?: (event: React.MouseEvent) => void;
}
interface MenuProps {
    children?: React.ReactElement | React.ReactNode;
    options?: Array<MenuOptionProps>;
    fitContent?: boolean;
}

declare const Menu: react__default.FC<MenuProps>;

declare const MenuWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    fitContent?: boolean | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const MenuChildrenWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const MenuListWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, {}>;

declare const MenuOption: react__default.FC<MenuOptionProps>;

interface AvatarProps {
    img?: string;
    placeholder: string;
}

declare const Avatar: react__default.FC<AvatarProps>;

declare const AvatarWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface FullscreenErrorProps {
    title: string;
    description?: string;
    image?: string | React.ReactElement;
    children?: React.ReactElement | React.ReactNode;
    action?: ButtonProps;
}

declare const FullscreenError: react__default.FC<FullscreenErrorProps>;

declare const StyledScreenError: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

declare const ErrorHeaderSlot: react_slotify.SlotType<object>;

declare const FilterError: () => react__default.JSX.Element;

declare const FilterErrorWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const FilterIconWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface Breadcrumb {
    link: string;
    children: string | React.ReactElement | React.ReactNode;
}
interface BreadcrumbsProps {
    breadcrumbs: Array<Breadcrumb>;
    onCrumbClick: (link: string) => void;
}

declare const Breadcrumbs: react__default.FC<BreadcrumbsProps>;

declare const BreadcrumbsWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface Option {
    id: string;
    title: string;
    value: string | number;
}
interface DropdownOptionProps extends Option {
    selected: boolean;
    onSelect: (option: Option, checked: boolean) => void;
    checkBox?: boolean;
}

declare const DropdownOption: react__default.FC<DropdownOptionProps>;

declare const StyledDropdownOption: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    selected: boolean;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledDropdownOptionContent: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

type OmitedInput = Omit<InputProps, 'value'>;
interface SelectProps extends OmitedInput {
    value: Array<Option>;
    options: Array<Option>;
    multiSelect?: boolean;
    disableSearch?: boolean;
    onSelectOption: (value: Array<Option>) => void;
}

declare const Dropdown: react__default.FC<SelectProps>;

declare const StatusColor: {
    succsess: string;
    error: string;
    info: string;
    warning: string;
    default: string;
};
interface StatusProps {
    status: keyof typeof StatusColor;
    children?: React.ReactElement | React.ReactNode;
}

declare const Status: react__default.FC<StatusProps>;

declare const StyledIndicator: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    color?: string | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
declare const StyledStatusWrapper: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface ToggleReturn {
    flag: boolean;
    toggle: () => void;
    toggleOff: () => void;
    toggleOn: () => void;
}
declare const useToggle: (initialToggleState?: boolean) => ToggleReturn;

/**
 * Simple object check.
 * @param item
 * @returns {boolean}
 */
declare function isObject(item: unknown): unknown;
/**
 * Deep merge two objects.
 * @param target
 * @param ...sources
 */
declare function mergeDeep(target: object, ...sources: Array<object>): object;

declare function reloadPage(): void;

export { Avatar, type AvatarProps, AvatarWrapper, Badge, BadgeColor, type BadgeColorValues, type BadgeProps, BadgeVariants, BadgeWrapper, BaseModal, type BaseModalProps, type Breadcrumb, Breadcrumbs, type BreadcrumbsProps, BreadcrumbsWrapper, Button, ButtonColor, type ButtonColorValues, type ButtonProps, ButtonSize, ButtonVariants, ButtonWrapper, Card, CardContent, CardFooter, type CardFooterProps, CardFooterSlot, CardHeader, type CardHeaderProps, CardHeaderSlot, type CardProps, Checkbox, type CheckboxProps, ColorMap, Content, type ContentProps, ContentSlot, DefaultEmptySlot, DefaultErrorSlot, DefaultLayout, type DefaultLayoutProps, DefaultLoadingSlot, Dropdown, DropdownOption, type DropdownOptionProps, ErrorHeaderSlot, FilterError, FilterErrorWrapper, FilterIconWrapper, Footer, type FooterProps, FooterSlot, FullscreenError, type FullscreenErrorProps, Header, type HeaderProps, HeaderSlot, Hoverable, HoverableWrapper, Input, type InputBaseColor, type InputProps, type InputSize, LayoutFullWindow, Menu, MenuChildrenWrapper, MenuListWrapper, MenuOption, type MenuOptionProps, type MenuProps, MenuWrapper, ModalWindow, Navigation, NavigationFooter, NavigationFooterWrapper, NavigationOption, type NavigationOptionProps, type NavigationProps, type OmitedInput, type Option, type OptionProps, PageContent, PageContentWrapper, PageHeader, PageHeaderActions, type PageHeaderProps, PageHeaderSlot, PageHeaderWrapper, PageLayout, PageLayoutWrapper, Portal, type PortalProps, type SelectProps, Status, StatusColor, type StatusProps, StyledCardContent, StyledCardFooter, StyledCardHeader, StyledCardImageWrapper, StyledCardTextWrapper, StyledCardWrapper, StyledCheckbox, StyledDropdownOption, StyledDropdownOptionContent, StyledFullLayout, StyledIndicator, StyledInput, StyledInputContainer, StyledInputWrapper, StyledLogoWrapper, StyledModalContent, StyledModalFooter, StyledModalHeader, StyledModalTextWrapper, StyledNavOption, StyledNavigationWrapper, StyledOptionsWrapper, StyledScreenError, StyledStatusWrapper, ThemeProvider, type ToggleReturn, Typography, TypographyColors, type TypographyProps, TypographyVariants, TypographyWrapper, ecosystemTheme, isObject, mergeDeep, reloadPage, useToggle };