@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_react from '@emotion/react';
import { Theme } from '@emotion/react';
import * as _emotion_styled from '@emotion/styled';
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 ButtonColorMap: (theme: Theme) => Record<keyof typeof ButtonColor, ButtonColorValues>;

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 ecosystemTheme: Theme;

declare const ThemeProvider: react__default.FC<{
    children: react__default.ReactNode;
    theme?: 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 ColorMap: {
    [x: string]: string;
};

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

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

declare const Text: react__default.FC<TextProps>;

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 BadgeColorMap: (theme: Theme) => Record<keyof typeof BadgeColor, BadgeColorValues>;

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;
}>;

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

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>>;
    }>;
};

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

declare const DefaultLayout: react__default.FC<DefaultLayoutProps>;

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 MenuOption: react__default.FC<MenuOptionProps>;

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>, {}>;

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

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>, {}>;

declare const Avatar: react__default.FC<AvatarProps>;

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 StyledSelectWrapper: _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 StyledDropdownOptionsWrapper: _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 StyledBadgeContaier: _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 Dropdown: react__default.FC<SelectProps>;

type StatusColorValues = 'succsess' | 'error' | 'info' | 'warning' | 'default';
declare const StatusColor: (theme: Theme) => {
    succsess: string;
    error: string;
    info: string;
    warning: string;
    default: string;
};
interface StatusProps {
    status: StatusColorValues;
    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;

interface TableColumn<T extends object> {
    title: string;
    accessor: keyof T;
    render: (row: T[keyof T]) => React.ReactElement;
    span?: number;
}
interface TableProps<T extends object> {
    data: Array<T>;
    columns: Array<TableColumn<T>>;
    onRowClick?: (row: T) => void;
}

declare const Table: <T extends object>(props: TableProps<T>) => react__default.JSX.Element;

declare const TableWrapperStyled: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, {}>;
declare const TableHeaderWrapperStyled: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, {}>;
declare const TableCellStyled: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
} & {
    isHeader?: boolean | undefined;
}, react.DetailedHTMLProps<react.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, {}>;
declare const TableRowStyled: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, {}>;
declare const TableColumnStyled: _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 TableContentStyled: _emotion_styled.StyledComponent<{
    theme?: _emotion_react.Theme | undefined;
    as?: react.ElementType<any, keyof react.JSX.IntrinsicElements> | undefined;
}, react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

interface Tab {
    title: string | React.ReactElement;
    value: string | boolean | number;
}
interface TabsProps {
    selected: Tab['value'];
    options: Array<Tab>;
    onSelect: (tab: Tab) => void;
}

declare const Tabs: react__default.FC<TabsProps>;

declare const TabsWrapperStyled: _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 TabItemWrapper: _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>, {}>;

export { Avatar, type AvatarProps, AvatarWrapper, Badge, BadgeColor, BadgeColorMap, type BadgeColorValues, type BadgeProps, BadgeVariants, BadgeWrapper, BaseModal, type BaseModalProps, type Breadcrumb, Breadcrumbs, type BreadcrumbsProps, BreadcrumbsWrapper, Button, ButtonColor, ButtonColorMap, 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, DefaultLayout, 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, type ModalProps, ModalWindow, Navigation, NavigationFooter, NavigationFooterWrapper, NavigationOption, type NavigationOptionProps, type NavigationProps, type OmitedInput, type Option, type OptionProps, PageLayout, Portal, type PortalProps, type SelectProps, Status, StatusColor, type StatusColorValues, type StatusProps, StyledBadgeContaier, StyledCardContent, StyledCardFooter, StyledCardHeader, StyledCardImageWrapper, StyledCardTextWrapper, StyledCardWrapper, StyledCheckbox, StyledDropdownOption, StyledDropdownOptionContent, StyledDropdownOptionsWrapper, StyledIndicator, StyledInput, StyledInputContainer, StyledInputWrapper, StyledLogoWrapper, StyledModalContent, StyledModalFooter, StyledModalHeader, StyledModalTextWrapper, StyledNavOption, StyledNavigationWrapper, StyledOptionsWrapper, StyledScreenError, StyledSelectWrapper, StyledStatusWrapper, type Tab, TabItemWrapper, Table, TableCellStyled, type TableColumn, TableColumnStyled, TableContentStyled, TableHeaderWrapperStyled, type TableProps, TableRowStyled, TableWrapperStyled, Tabs, type TabsProps, TabsWrapperStyled, Text, TextColors, type TextProps, TextVariants, TextWrapper, ThemeProvider, type ToggleReturn, ecosystemTheme, isObject, mergeDeep, reloadPage, useToggle };