/// <reference types="react" />

import { AccordionProps as AccordionProps_2 } from 'baseui/accordion';
import { ALIGN } from 'baseui/radio';
import { AriaRole } from 'react';
import { PLACEMENT as BADGE_PLACEMENT } from 'baseui/badge';
import { BadgeProps as BadgeProps_2 } from 'baseui/badge';
import { BreadcrumbsProps as BreadcrumbsProps_2 } from 'baseui/breadcrumbs';
import { ButtonProps as ButtonProps_2 } from 'baseui/button';
import { CardOverrides } from 'baseui/card';
import { CardProps as CardProps_2 } from 'baseui/card/types';
import { ChartProps } from 'lightweight-charts-react-components';
import { CheckboxProps as CheckboxProps_2 } from 'baseui/checkbox';
import { CreateThemeOptions as CreateThemeOptions_2 } from '@uiw/codemirror-themes';
import { ANCHOR as DRAWER_ANCHOR } from 'baseui/drawer';
import { SIZE as DRAWER_SIZE } from 'baseui/drawer';
import { DrawerOverrides } from 'baseui/drawer';
import { DrawerProps as DrawerProps_2 } from 'baseui/drawer';
import { FC } from 'react';
import { FileUploaderProps as FileUploaderProps_2 } from 'baseui/file-uploader';
import { FormControlProps as FormControlProps_2 } from 'baseui/form-control';
import { ForwardedRef } from 'react';
import type { ForwardRefExoticComponent } from 'react';
import { HeadingProps } from 'baseui/list';
import type { HTMLAttributes } from 'react';
import { Input as Input_2 } from 'baseui/input';
import { InputProps as InputProps_2 } from 'baseui/input';
import type { JSX as JSX_2 } from 'react/jsx-runtime';
import type { JSXElementConstructor } from 'react';
import type { Key } from 'react';
import { LABEL_PLACEMENT } from 'baseui/checkbox';
import { LabelProps } from 'baseui/list';
import type { LineData } from 'lightweight-charts';
import { ARTWORK_SIZES as LIST_ARTWORK_SIZES } from 'baseui/list';
import { ListProps } from 'baseui/list';
import { Merge } from 'ts-essentials';
import { ModalProps as ModalProps_2 } from 'baseui/modal';
import type { NamedExoticComponent } from 'react';
import { Notification as Notification_3 } from 'baseui/notification';
import type { OnChangeHandler } from 'baseui/accordion';
import type { PanelOverrides } from 'baseui/accordion';
import type { PanelProps as PanelProps_2 } from 'baseui/accordion';
import { ProgressBarProps as ProgressBarProps_2 } from 'baseui/progress-bar';
import { RadioGroupProps as RadioGroupProps_2 } from 'baseui/radio';
import { RadioProps as RadioProps_2 } from 'baseui/radio';
import { default as React_2 } from 'react';
import { ReactCodeMirrorProps } from '@uiw/react-codemirror';
import { ReactElement } from 'react';
import { ReactNode } from 'react';
import type { RefAttributes } from 'react';
import { SelectProps as SelectProps_2 } from 'baseui/select';
import { SIZE } from 'baseui/select';
import type { SkeletonPropsT } from 'baseui/skeleton';
import type { StandardEngine } from 'styletron-standard';
import { StatefulMenuProps } from 'baseui/menu';
import { StatefulTooltipProps as StatefulTooltipProps_2 } from 'baseui/tooltip';
import { StyledAction } from 'baseui/card';
import { StyledBody } from 'baseui/card';
import { StyledContents } from 'baseui/card';
import { StyledHeaderImage } from 'baseui/card';
import { StyledRoot } from 'baseui/card';
import { StyledThumbnail } from 'baseui/card';
import { StyledTitle } from 'baseui/card';
import { StyledWrapper } from 'baseui/card';
import { StyleObject } from 'styletron-react';
import type { StyletronComponent } from 'styletron-react';
import { TableBuilderColumnProps } from 'baseui/table-semantic/types';
import { TableBuilderProps } from 'baseui/table-semantic/types';
import { TableProps } from 'baseui/table-semantic/types';
import { TabProps as TabProps_2 } from 'baseui/tabs';
import { ORIENTATION as TABS_ORIENTATION } from 'baseui/tabs';
import { TabsProps as TabsProps_2 } from 'baseui/tabs';
import { TagProps as TagProps_2 } from 'baseui/tag';
import { TextareaProps as TextareaProps_2 } from 'baseui/textarea';
import { Theme } from 'baseui';
import type { Time } from 'lightweight-charts';
import { TooltipProps as TooltipProps_2 } from 'baseui/tooltip';
import type { XOR } from 'ts-xor';

export declare const Accordion: FC<AccordionProps>;

export declare type AccordionProps = Omit<AccordionProps_2, "stateReducer"> & {
    stateReducer?: AccordionProps_2["stateReducer"];
};

export { ALIGN }

export declare const ArrowUpIcon: NamedExoticComponent<IconProps>;

export declare const AuthDropdownContainer: FC<AuthDropdownContainerProps>;

export declare type AuthDropdownContainerProps = {
    username?: string;
    children?: ReactNode;
    onLogout?: () => void;
};

export declare const AuthItem: FC<AuthItemProps>;

export declare type AuthItemProps = {
    amount: string;
    cents?: string;
    currency: string;
};

export declare const Badge: FC<BadgeProps>;

export declare enum BADGE_COLOR {
    accent = "accent",
    warning = "warning",
    positive = "positive",
    negative = "negative"
}

export declare enum BADGE_HIERARCHY {
    low = "low",
    high = "high"
}

export { BADGE_PLACEMENT }

export declare type BadgeProps = Omit<BadgeProps_2, "hierarchy" | "color" | "shape"> & {
    hierarchy?: BADGE_HIERARCHY;
    color?: BADGE_COLOR;
};

export declare const Brand: FC<BrandProps>;

export declare type BrandProps = {
    color?: string;
    className?: string;
};

export declare const Breadcrumbs: React_2.FC<BreadcrumbsProps>;

export declare const BreadcrumbsItem: FC<BreadcrumbsItemProps>;

export declare type BreadcrumbsItemProps = {
    href?: string;
    isActive?: boolean;
    disabled?: boolean;
    children?: ReactNode;
    linkComponent?: LinkComponentRenderFunction;
};

export declare type BreadcrumbsProps = BreadcrumbsProps_2;

export declare const Button: ForwardRefExoticComponent<ButtonProps & RefAttributes<HTMLButtonElement>>;

export declare enum BUTTON_KIND {
    primary = "primary",
    secondary = "secondary",
    tertiary = "tertiary",
    danger = "danger",
    toggle = "toggle",
    text = "text"
}

export declare enum BUTTON_SIZE {
    mini = "mini",
    default = "default",
    compact = "compact",
    large = "large"
}

export declare type ButtonCommonProps = Omit<Merge<React.ComponentProps<"button">, Merge<ButtonProps_2, {
    size?: BUTTON_SIZE;
    disabled?: boolean;
    isLoading?: boolean;
    className?: string;
    role?: AriaRole;
}>>, "ref">;

export declare const ButtonIcon: ForwardRefExoticComponent<Omit<ButtonProps, "colors" | "endEnhancer" | "size" | "startEnhancer" | "checked"> & {
    icon: ReactElement<any, string | JSXElementConstructor<any>>;
    size?: ButtonIconSize | undefined;
} & RefAttributes<HTMLButtonElement>>;

export declare type ButtonIconProps = Omit<ButtonProps, "checked" | "size" | "startEnhancer" | "endEnhancer" | "colors"> & {
    icon: ReactElement;
    size?: ButtonIconSize;
};

export declare type ButtonIconSize = BUTTON_SIZE.default | BUTTON_SIZE.large | BUTTON_SIZE.compact;

export declare type ButtonProps = XOR<ToggleButtonProps, RegularButtonProps>;

export declare const CancelIcon: NamedExoticComponent<IconProps>;

export declare const Card: React_2.FC<CardProps>;

export declare type CardProps = Omit<CardProps_2, "overrides"> & {
    /** This property set white headline at the top of the card */
    headline?: boolean;
    /** This property set 1px solid grey border to card */
    border?: boolean;
    overrides?: CardOverrides;
};

export declare const CaretDownIcon: NamedExoticComponent<IconProps>;

export declare const CaretUpIcon: NamedExoticComponent<IconProps>;

export declare const ChartIcon: NamedExoticComponent<IconProps>;

export declare const ChartWidget: ForwardRefExoticComponent<{
    data: LineData<Time>[];
    color?: string | undefined;
} & Omit<ChartProps, "children" | "onCrosshairMove"> & RefAttributes<HTMLDivElement>>;

export declare type ChartWidgetProps = {
    data: LineData[];
    color?: string;
} & Omit<ChartProps, "children" | "onCrosshairMove">;

export declare const Checkbox: FC<CheckboxProps>;

export declare type CheckboxProps = Omit<CheckboxProps_2, "checkmarkType" | "error">;

export declare const CheckmarkIcon: NamedExoticComponent<IconProps>;

export declare const ChevronDownIcon: NamedExoticComponent<IconProps>;

export declare const ChevronLeftIcon: NamedExoticComponent<IconProps>;

export declare const ChevronRightIcon: NamedExoticComponent<IconProps>;

export declare const ChevronUpIcon: NamedExoticComponent<IconProps>;

export declare const CloseIcon: NamedExoticComponent<IconProps>;

export declare enum CODE_FIELD_SIZE {
    small = "small",
    medium = "medium"
}

export declare const CodeField: ForwardRefExoticComponent<{
    code: string;
    extensions?: ReactCodeMirrorProps["extensions"];
    themeOverrides?: Partial<CreateThemeOptions_2> | undefined;
    displayCopy?: boolean | undefined;
    onCopy?: ((code: string) => void) | undefined;
    transformOnCopy?: ((code: string) => string) | undefined;
    showLineNumbers?: boolean | undefined;
    className?: string | undefined;
    editable?: ReactCodeMirrorProps["editable"];
    readOnly?: ReactCodeMirrorProps["readOnly"];
    onChange?: ReactCodeMirrorProps["onChange"];
    size?: CODE_FIELD_SIZE | undefined;
    codeMirrorClassName?: string | undefined;
    highlightOnHover?: boolean | undefined;
    customStyles?: CustomStyles | undefined;
} & HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;

export declare type CodeFieldProps = {
    code: string;
    extensions?: ReactCodeMirrorProps["extensions"];
    themeOverrides?: Partial<CreateThemeOptions_2>;
    displayCopy?: boolean;
    onCopy?: (code: string) => void;
    transformOnCopy?: (code: string) => string;
    showLineNumbers?: boolean;
    className?: string;
    editable?: ReactCodeMirrorProps["editable"];
    readOnly?: ReactCodeMirrorProps["readOnly"];
    onChange?: ReactCodeMirrorProps["onChange"];
    size?: CODE_FIELD_SIZE;
    codeMirrorClassName?: string;
    highlightOnHover?: boolean;
    customStyles?: CustomStyles;
} & HTMLAttributes<HTMLDivElement>;

export declare const CodeIcon: NamedExoticComponent<IconProps>;

export declare const COLORS: {
    readonly gray50: "#F1F1F1";
    readonly gray100: "#D6D6D6";
    readonly gray200: "#BDBDBD";
    readonly gray300: "#A3A3A3";
    readonly gray400: "#8A8A8A";
    readonly gray500: "#727272";
    readonly gray600: "#5B5B5B";
    readonly gray700: "#444444";
    readonly gray800: "#2F2F2F";
    readonly gray900: "#212121";
    readonly black: "#0F0F0F";
    readonly red50: "#FBEBEC";
    readonly red100: "#FBC0C4";
    readonly red200: "#FD949B";
    readonly red300: "#FD6670";
    readonly red400: "#FC3642";
    readonly red500: "#D9121F";
    readonly red600: "#B30D18";
    readonly red700: "#8A0810";
    readonly red800: "#62060C";
    readonly red900: "#340609";
    readonly purple50: "#F4EEFB";
    readonly purple100: "#E2CEFC";
    readonly purple200: "#D2AFFF";
    readonly purple300: "#C08FFF";
    readonly purple400: "#AE6FFF";
    readonly purple500: "#9748FF";
    readonly purple600: "#8426FF";
    readonly purple700: "#6200E1";
    readonly purple800: "#47049F";
    readonly purple900: "#2C0560";
    readonly blue50: "#EFF4FB";
    readonly blue100: "#CEE0FB";
    readonly blue200: "#ADCDFD";
    readonly blue300: "#87B6FC";
    readonly blue400: "#589AFC";
    readonly blue500: "#1567E3";
    readonly blue600: "#1056C0";
    readonly blue700: "#094194";
    readonly blue800: "#0A3068";
    readonly blue900: "#091E3E";
    readonly green50: "#D3F9EE";
    readonly green100: "#73ECC8";
    readonly green200: "#5AD2AE";
    readonly green300: "#4DB596";
    readonly green400: "#40997E";
    readonly green500: "#347F69";
    readonly green600: "#286653";
    readonly green700: "#1C4D3E";
    readonly green800: "#13352B";
    readonly green900: "#0C1F19";
    readonly yellow50: "#FCF6DE";
    readonly yellow100: "#FCE389";
    readonly yellow200: "#F9C406";
    readonly yellow300: "#D7A904";
    readonly yellow400: "#B79003";
    readonly yellow500: "#977702";
    readonly yellow600: "#7A6001";
    readonly yellow700: "#5D4901";
    readonly yellow800: "#403303";
    readonly yellow900: "#241D05";
    readonly orange50: "#FCF6DE";
    readonly orange100: "#FCE389";
    readonly orange200: "#F9C406";
    readonly orange300: "#D7A904";
    readonly orange400: "#B79003";
    readonly orange500: "#977702";
    readonly orange600: "#7A6001";
    readonly orange700: "#5D4901";
    readonly orange800: "#403303";
    readonly orange900: "#241D05";
};

export declare const CompleteIcon: NamedExoticComponent<IconProps>;

export declare const CopyButton: FC<CopyButtonProps>;

export declare type CopyButtonProps = Omit<CopyToClipboardComponentProps, "render"> & Omit<ButtonIconProps, "icon" | "onCopy">;

export declare const CopyIcon: NamedExoticComponent<IconProps>;

export declare type CopyToClipboardComponentProps = {
    textToCopy: string;
    render: (props: {
        onClick: () => void;
        copied: boolean;
    }) => JSX.Element;
    transformOnCopy?: (code: string) => string;
    onCopy?: (textToCopy: string) => void;
    copyTooltipText?: string;
    copiedTooltipText?: string;
};

export declare type CreateTheme = (instance: StandardEngine, options?: CreateThemeOptions) => CreateThemeReturnType;

export declare const createTheme: CreateTheme;

export declare type CreateThemeOptions = {
    enableDefaultFonts?: boolean;
    overrides?: any;
};

export declare type CreateThemeReturnType = {
    theme: Theme;
    fonts?: DefaultFonts;
};

export declare type CustomStyles = {
    [selector: string]: {
        [property: string]: string;
    };
};

export declare type DefaultFonts = {
    defaultRegularFont: string;
    defaultSemiBoldFont: string;
    defaultMonoRegularFont: string;
    defaultMediumFont: string;
};

export declare const DiscordIcon: NamedExoticComponent<IconProps>;

export declare const DotsIcon: NamedExoticComponent<IconProps>;

export declare const DownloadIcon: FC<IconProps>;

export declare const Drawer: FC<DrawerProps>;

export { DRAWER_ANCHOR }

export { DRAWER_SIZE }

export declare type DrawerOwnProps = {
    animate?: boolean;
    closeable?: boolean;
    overrides?: DrawerOverrides;
    anchor?: (typeof DRAWER_ANCHOR)[keyof typeof DRAWER_ANCHOR];
    size?: (typeof DRAWER_SIZE)[keyof typeof DRAWER_SIZE];
    showBackdrop?: boolean;
    autoFocus?: boolean;
};

export declare type DrawerProps = DrawerOwnProps & Omit<DrawerProps_2, keyof DrawerOwnProps>;

export declare const encodeInlineSvg: (inlineSvg: string) => string;

export declare const ErrorPage: React_2.FC<ErrorPageProps>;

export declare type ErrorPageBaseProps = {
    errorCode: number;
    errorDescription: string;
};

export declare type ErrorPageProps = XOR<ErrorPageWithActionElementProps, ErrorPageWithoutActionElementProps>;

export declare type ErrorPageWithActionElementProps = {
    actionElement?: React.ReactNode;
} & ErrorPageBaseProps;

export declare type ErrorPageWithoutActionElementProps = RedirectProps & ErrorPageBaseProps;

export declare const FileUploader: FC<FileUploaderProps>;

export declare type FileUploaderProps = FileUploaderProps_2;

export declare const FitToScreenIcon: NamedExoticComponent<IconProps>;

export declare const FormControl: FC<FormControlProps>;

export declare type FormControlProps = Omit<FormControlProps_2, "counter" | "positive"> & {
    size?: INPUT_SIZE;
    readOnly?: boolean;
    isLoading?: boolean;
    counter?: ICounter;
    required?: boolean;
};

export declare const GithubIcon: NamedExoticComponent<IconProps>;

export declare type GroupedItems = {
    __ungrouped: Items;
    [x: string]: Items;
};

export declare const HeartIcon: NamedExoticComponent<IconProps>;

export declare type IconProps = {
    color?: string;
    $color?: string;
    size?: number | string;
    $size?: number | string;
    title?: string;
    className?: string;
};

export declare interface ICounter {
    maxLength: number;
    length: number;
}

export declare const InfoIcon: NamedExoticComponent<IconProps>;

export declare const Input: ForwardRefExoticComponent<Omit<InputProps_2, "positive" | "size" | "error"> & {
    size?: INPUT_SIZE | undefined;
    kind?: INPUT_KIND | undefined;
    isLoading?: boolean | undefined;
} & RefAttributes<Input_2>>;

export declare enum INPUT_KIND {
    primary = "primary",
    secondary = "secondary"
}

export declare enum INPUT_SIZE {
    small = "small",
    medium = "medium"
}

export declare type InputProps = Omit<InputProps_2, "size" | "positive" | "error"> & {
    size?: INPUT_SIZE;
    kind?: INPUT_KIND;
    isLoading?: boolean;
};

export declare type ItemDivider = {
    divider: true;
};

export declare type Items = Array<MenuItem | ItemDivider>;

export { LABEL_PLACEMENT as CHECKBOX_LABEL_PLACEMENT }
export { LABEL_PLACEMENT as TOGGLE_LABEL_PLACEMENT }

export declare type LinkComponentProps = {
    children?: React_2.ReactNode;
    className?: string;
    href?: string;
};

export declare type LinkComponentRenderFunction = (props: LinkComponentProps) => ReactElement;

export declare const LinkedinIcon: NamedExoticComponent<IconProps>;

export { LIST_ARTWORK_SIZES }

export declare const ListHeading: FC<ListHeadingProps>;

export declare type ListHeadingProps = HeadingProps;

export declare const ListItem: FC<ListItemProps>;

export declare const ListItemLabel: FC<ListItemLabelProps>;

export declare type ListItemLabelProps = LabelProps & {
    disabled?: boolean;
};

export declare type ListItemProps = ListProps & {
    isActive?: boolean;
    disabled?: boolean;
};

export declare const LoginIcon: NamedExoticComponent<IconProps>;

export declare const LogoutIcon: NamedExoticComponent<IconProps>;

export declare const Menu: FC<MenuProps>;

export declare enum MENU_SIZE {
    "small" = "small",
    "medium" = "medium",
    "large" = "large"
}

export declare const MenuIcon: NamedExoticComponent<IconProps>;

export declare type MenuItem = {
    /** Highlights item and adds a checkbox if true */
    selected?: boolean;
    suffixText?: string;
    startEnhancer?: ReactElement;
    endEnhancer?: ReactElement;
    /** Adds checkmark */
    isActive?: boolean;
    linkComponent?: LinkComponentRenderFunction;
    href?: string;
    /** Highlights item as it was selected */
    isHighlighted?: boolean;
    label: ReactNode;
    disabled?: boolean;
};

export declare type MenuProps = Omit<StatefulMenuProps, "items"> & {
    size?: MENU_SIZE;
    items: Items | GroupedItems;
    isDropdown?: boolean;
};

export declare const MinusIcon: NamedExoticComponent<IconProps>;

export declare const Modal: FC<ModalProps>;

export declare const ModalBody: FC<ModalBodyProps>;

export declare type ModalBodyProps = {
    children?: ReactNode;
};

export declare const ModalFooter: FC<ModalFooterProps>;

export declare type ModalFooterProps = {
    children?: ReactNode;
};

export declare const ModalHeader: FC<ModalHeaderProps>;

export declare type ModalHeaderProps = {
    children?: ReactNode;
};

export declare type ModalProps = Omit<ModalProps_2, "animate" | "closable"> & {
    animate?: boolean;
    closeable?: boolean;
};

export declare type MultipleToggleGroupProps<O extends ToggleGroupOption> = {
    multiple: true;
    value: Array<O["key"]>;
    onChange: (value: Array<O["key"]>) => void;
} & ToggleGroupBaseProps<O>;

export declare const NavigationBar: FC<NavigationBarProps>;

export declare type NavigationBarProps = {
    items: NavigationItem[];
    onItemClick?: (item: NavigationItem) => void;
    itemAs?: (item: NavigationItem) => ReactNode;
    onLogin?: () => void;
    isAuth?: boolean;
    authDropdownContainer?: ReactNode;
    brand?: ReactNode;
    username?: string;
    noLogin?: boolean;
    className?: string;
    fixed?: boolean;
};

export declare type NavigationItem<T = unknown> = T & {
    id: string;
    label: ReactNode;
    selected?: boolean;
    disabled?: boolean;
    children?: Array<NavigationItem<T>>;
    href?: string;
};

declare const Notification_2: React_2.FC<NotificationProps>;
export { Notification_2 as Notification }

export declare enum NOTIFICATION_KIND {
    info = "info",
    warning = "warning",
    positive = "positive",
    negative = "negative"
}

export declare type NotificationProps = Omit<React_2.ComponentProps<typeof Notification_3>, "kind"> & {
    children: React_2.ReactNode;
    hideIcon?: boolean;
    kind?: NOTIFICATION_KIND;
    icon?: React_2.ReactNode;
    isAction?: boolean;
    actionLabel?: string;
};

export declare type PageElementProps = {
    page: number;
    label?: ReactNode;
    linkMapper?: (page: number) => string;
    pageHandler?: (page: number) => void;
    disabled?: boolean;
    active?: boolean;
    buttonSize: BUTTON_SIZE;
};

export declare const Pagination: ({ currentPage, totalPages, visiblePages, pageHandler, linkMapper, buttonSize, }: PaginationProps) => JSX_2.Element;

export declare type PaginationProps = {
    currentPage: number;
    totalPages: number;
    visiblePages?: number;
    linkMapper?: (page: number) => string;
    pageHandler?: (page: number) => void;
    buttonSize?: BUTTON_SIZE;
};

export declare const Panel: ForwardRefExoticComponent<{
    children: ReactNode;
    disabled?: boolean | undefined;
    'aria-controls'?: string | undefined;
    key?: Key | undefined;
    onChange?: OnChangeHandler | undefined;
    onClick?: ((e: Event) => unknown) | undefined;
    onKeyDown?: ((e: KeyboardEvent) => unknown) | undefined;
    overrides?: PanelOverrides | undefined;
    title?: ReactNode;
    renderPanelContent?: boolean | undefined;
    renderAll?: boolean | undefined;
} & {
    expanded?: boolean | undefined;
} & {
    description?: string | undefined;
    icon?: ReactNode;
} & RefAttributes<HTMLElement>>;

export declare type PanelProps = PanelProps_2 & {
    description?: string;
    icon?: ReactNode;
};

export declare const PlusIcon: NamedExoticComponent<IconProps>;

/**
 * @deprecated
 * Use `COLORS` instead.
 */
export declare const PRIMITIVE_COLORS: {
    gray50: "#F1F1F1";
    gray100: "#D6D6D6";
    gray200: "#BDBDBD";
    gray300: "#A3A3A3";
    gray400: "#8A8A8A";
    gray500: "#727272";
    gray600: "#5B5B5B";
    gray700: "#444444";
    gray800: "#2F2F2F";
    gray900: "#212121";
    black: "#0F0F0F";
    red50: "#FBEBEC";
    red100: "#FBC0C4";
    red200: "#FD949B";
    red300: "#FD6670";
    red400: "#FC3642";
    red500: "#D9121F";
    red600: "#B30D18";
    red700: "#8A0810";
    red800: "#62060C";
    red900: "#340609";
    purple50: "#F4EEFB";
    purple100: "#E2CEFC";
    purple200: "#D2AFFF";
    purple300: "#C08FFF";
    purple400: "#AE6FFF";
    purple500: "#9748FF";
    purple600: "#8426FF";
    purple700: "#6200E1";
    purple800: "#47049F";
    purple900: "#2C0560";
    blue50: "#EFF4FB";
    blue100: "#CEE0FB";
    blue200: "#ADCDFD";
    blue300: "#87B6FC";
    blue400: "#589AFC";
    blue500: "#1567E3";
    blue600: "#1056C0";
    blue700: "#094194";
    blue800: "#0A3068";
    blue900: "#091E3E";
    green50: "#D3F9EE";
    green100: "#73ECC8";
    green200: "#5AD2AE";
    green300: "#4DB596";
    green400: "#40997E";
    green500: "#347F69";
    green600: "#286653";
    green700: "#1C4D3E";
    green800: "#13352B";
    green900: "#0C1F19";
    yellow50: "#FCF6DE";
    yellow100: "#FCE389";
    yellow200: "#F9C406";
    yellow300: "#D7A904";
    yellow400: "#B79003";
    yellow500: "#977702";
    yellow600: "#7A6001";
    yellow700: "#5D4901";
    yellow800: "#403303";
    yellow900: "#241D05";
    orange50: "#FCF6DE";
    orange100: "#FCE389";
    orange200: "#F9C406";
    orange300: "#D7A904";
    orange400: "#B79003";
    orange500: "#977702";
    orange600: "#7A6001";
    orange700: "#5D4901";
    orange800: "#403303";
    orange900: "#241D05";
};

export declare const ProfileIcon: NamedExoticComponent<IconProps>;

export declare enum PROGRESS_BAR_SIZE {
    small = "small",
    medium = "medium",
    large = "large"
}

export declare const ProgressBar: FC<ProgressBarProps>;

export declare type ProgressBarProps = Omit<ProgressBarProps_2, "steps" | "size" | "showLabel" | "successValue" | "getProgressLabel" | "infinite"> & {
    size?: PROGRESS_BAR_SIZE;
    className?: string;
    showLabel?: boolean;
    getProgressLabel?: (value: number, minValue: number, maxValue: number) => string;
    infinite?: boolean;
};

export declare const Radio: FC<RadioProps>;

export declare const RadioGroup: FC<RadioGroupProps>;

export declare type RadioGroupProps = RadioGroupProps_2 & {
    name: string;
};

export declare type RadioProps = RadioProps_2;

export declare type RedirectProps = {
    redirectPath: string;
    redirectTitle: string;
};

export declare type RegularButtonProps = Merge<ButtonCommonProps, {
    kind?: Exclude<BUTTON_KIND, BUTTON_KIND.toggle>;
}>;

export declare const ResizeIcon: NamedExoticComponent<IconProps>;

export declare const SearchIcon: NamedExoticComponent<IconProps>;

export declare const Select: React_2.FC<SelectProps>;

export declare enum SELECT_KIND {
    primary = "primary",
    secondary = "secondary"
}

export declare enum SELECT_SIZE {
    small = "small",
    medium = "medium"
}

export declare type SelectProps = Omit<SelectProps_2, "size" | "positive" | "filterOutSelected" | "openOnClick"> & {
    size?: SELECT_SIZE;
    kind?: SELECT_KIND;
};

export declare const SeparatorIcon: NamedExoticComponent<IconProps>;

export declare type SingleToggleGroupProps<O extends ToggleGroupOption> = {
    multiple?: false;
    value: [O["key"]];
    onChange: (value: [O["key"]] | []) => void;
} & ToggleGroupBaseProps<O>;

export { SIZE }

export declare const Skeleton: FC<SkeletonProps>;

export declare type SkeletonProps = SkeletonPropsT;

export declare const SPACE: {
    readonly 2: "2px";
    readonly 4: "4px";
    readonly 8: "8px";
    readonly 12: "12px";
    readonly 16: "16px";
    readonly 24: "24px";
    readonly 32: "32px";
    readonly 48: "48px";
    readonly 64: "64px";
    readonly 96: "96px";
    readonly 128: "128px";
};

export declare const Spinner: FC<SpinnerProps>;

export declare enum SPINNER_KIND {
    dark = "dark",
    light = "light"
}

export declare enum SPINNER_SIZE {
    xSmall = "xSmall",
    small = "small",
    medium = "medium",
    large = "large",
    xLarge = "xLarge"
}

export declare type SpinnerProps = {
    size?: SPINNER_SIZE;
    kind?: SPINNER_KIND;
    style?: StyleObject;
};

export declare const StatefulTooltip: React_2.FC<StatefulTooltipProps>;

export declare type StatefulTooltipProps = StatefulTooltipProps_2 & TooltipCommonProps;

export { StyledAction }

export { StyledBody }

export declare const StyledChart: ForwardRefExoticComponent<ChartProps & RefAttributes<HTMLDivElement>>;

export { StyledContents }

export { StyledHeaderImage }

export { StyledRoot }

export declare const StyledTableSemantic: StyletronComponent<"table", {
    $width?: string | null | undefined;
}>;

export declare const StyledTableSemanticBody: StyletronComponent<"tbody", {}>;

export declare const StyledTableSemanticBodyCell: StyletronComponent<"td", any>;

export declare const StyledTableSemanticBodyRow: StyletronComponent<"tr", {
    $col?: {} | undefined;
    $colIndex?: number | null | undefined;
    $divider?: "grid" | "horizontal" | "vertical" | "clean" | undefined;
}>;

export declare const StyledTableSemanticEmptyMessage: StyletronComponent<"div", {}>;

export declare const StyledTableSemanticHead: StyletronComponent<"thead", {}>;

export declare const StyledTableSemanticHeadCell: StyletronComponent<"th", any>;

export declare const StyledTableSemanticHeadCellSortable: StyletronComponent<"th", any>;

export declare const StyledTableSemanticHeadRow: StyletronComponent<"tr", {}>;

export declare const StyledTableSemanticRoot: StyletronComponent<"div", {
    $divider?: "grid" | "horizontal" | "vertical" | "clean" | undefined;
}>;

export { StyledThumbnail }

export { StyledTitle }

export { StyledWrapper }

export declare const svgInlineDotsPattern: string;

export declare const Tab: FC<TabProps>;

export declare enum TAB_KIND {
    primary = "primary",
    secondary = "secondary"
}

export declare enum TABLE_DIVIDER {
    horizontal = "horizontal",
    vertical = "vertical",
    grid = "grid",
    clean = "clean"
}

export declare enum TABLE_SIZE {
    compact = "compact",
    default = "default",
    spacious = "spacious"
}

export declare const TableSemantic: FC<TableSemanticProps>;

export declare const TableSemanticBuilder: FC<TableSemanticBuilderProps>;

export declare const TableSemanticBuilderColumn: FC<TableSemanticBuilderColumnProps>;

export declare type TableSemanticBuilderColumnProps = Omit<TableBuilderColumnProps<any>, "size" | "divider"> & {
    size?: TABLE_SIZE;
    divider?: TABLE_DIVIDER;
};

export declare type TableSemanticBuilderProps = Omit<TableBuilderProps<any>, "size" | "divider"> & {
    size?: TABLE_SIZE;
    divider?: TABLE_DIVIDER;
};

export declare type TableSemanticProps = Omit<TableProps, "size" | "divider"> & {
    size?: TABLE_SIZE;
    divider?: TABLE_DIVIDER;
};

export declare type TabProps = TabProps_2 & {
    startEnhancer?: ReactNode;
    endEnhancer?: ReactNode;
    kind?: TAB_KIND;
};

export declare const Tabs: FC<TabsProps>;

export { TABS_ORIENTATION }

export declare type TabsProps = TabsProps_2;

export declare const Tag: FC<TagProps>;

export declare enum TAG_KIND {
    gray = "gray",
    blue = "blue",
    green = "green",
    yellow = "yellow",
    purple = "purple",
    red = "red",
    white = "white"
}

export declare enum TAG_SIZE {
    s = "s",
    m = "m"
}

export declare type TagProps = Omit<TagProps_2, "kind" | "variant" | "color" | "size" | "closeable" | "disabled" | "onClick" | "onKeyDown" | "onActionClick" | "onActionKeyDown" | "isFocused" | "isHovered"> & {
    kind?: TAG_KIND;
    size?: TAG_SIZE;
    fill?: boolean;
};

export declare const TelegramIcon: NamedExoticComponent<IconProps>;

export declare const Textarea: FC<TextareaProps>;

export declare enum TEXTAREA_KIND {
    primary = "primary",
    secondary = "secondary"
}

export declare enum TEXTAREA_SIZE {
    small = "small",
    medium = "medium"
}

export declare type TextareaProps = Omit<TextareaProps_2, "positive"> & {
    size?: TEXTAREA_SIZE;
    isLoading?: boolean;
    kind?: TEXTAREA_KIND;
};

export declare const Toggle: FC<ToggleProps>;

export declare type ToggleButtonProps = Merge<ButtonCommonProps, {
    kind: BUTTON_KIND.toggle;
    checked?: boolean;
}>;

export declare const ToggleGroup: <T extends ToggleGroupOption>(props: ToggleGroupProps<T> & {
    ref?: ForwardedRef<HTMLDivElement> | undefined;
}) => ReturnType<typeof ToggleGroupInner>;

export declare type ToggleGroupBaseProps<O extends ToggleGroupOption> = {
    label?: string;
    options: O[] | Readonly<O[]>;
    className?: string;
    disabled?: boolean;
    size?: BUTTON_SIZE;
};

export declare const ToggleGroupInner: <T extends ToggleGroupOption>({ options, value, onChange, disabled, label, multiple, className, size }: ToggleGroupProps<T>, ref: ForwardedRef<HTMLDivElement>) => JSX_2.Element;

export declare type ToggleGroupOption = {
    label: string;
    key: string;
    disabled?: boolean;
};

export declare type ToggleGroupProps<O extends ToggleGroupOption> = XOR<MultipleToggleGroupProps<O>, SingleToggleGroupProps<O>>;

export declare type ToggleProps = Omit<CheckboxProps_2, "checkmarkType" | "error" | "isIndeterminate">;

export declare const Tooltip: React_2.FC<TooltipProps>;

export declare enum TOOLTIP_KIND {
    DEFAULT = "default",
    ERROR = "error",
    SUCCESS = "success"
}

export declare type TooltipCommonProps = {
    kind?: TOOLTIP_KIND;
};

export declare type TooltipProps = TooltipProps_2 & TooltipCommonProps;

export declare const TwitterIcon: NamedExoticComponent<IconProps>;

export declare const WarningIcon: NamedExoticComponent<IconProps>;


export * from "baseui/typography";

export { }