/// <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 type { ChartOptions as ChartOptions_2 } from 'lightweight-charts';
import { CheckboxProps as CheckboxProps_2 } from 'baseui/checkbox';
import { CreateThemeOptions as CreateThemeOptions_2 } from '@uiw/codemirror-themes';
import type { DeepPartial } from 'lightweight-charts';
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 type { IChartApi } from 'lightweight-charts';
import { Input as Input_2 } from 'baseui/input';
import { InputProps as InputProps_2 } from 'baseui/input';
import { IPriceLine } from 'lightweight-charts';
import type { IPriceScaleApi } from 'lightweight-charts';
import type { ISeriesApi } from 'lightweight-charts';
import type { ITimeScaleApi } from 'lightweight-charts';
import type { JSX as JSX_2 } from 'react/jsx-runtime';
import type { JSXElementConstructor } 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 type { LogicalRangeChangeEventHandler } from 'lightweight-charts';
import { ModalProps as ModalProps_2 } from 'baseui/modal';
import type { MouseEventHandler } from 'lightweight-charts';
import type { NamedExoticComponent } from 'react';
import { Notification as Notification_3 } from 'baseui/notification';
import { PanelProps as PanelProps_2 } from 'baseui/accordion';
import { PriceLineOptions } from 'lightweight-charts';
import type { PriceScaleOptions as PriceScaleOptions_2 } from 'lightweight-charts';
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 type { Range as Range_2 } from 'lightweight-charts';
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 type { SeriesDataItemTypeMap } from 'lightweight-charts';
import type { SeriesMarker } from 'lightweight-charts';
import type { SeriesPartialOptionsMap } from 'lightweight-charts';
import type { SeriesType as SeriesType_2 } from 'lightweight-charts';
import { SIZE } from 'baseui/select';
import type { SizeChangeEventHandler } from 'lightweight-charts';
import type { SkeletonPropsT } from 'baseui/skeleton';
import type { StandardEngine } from 'styletron-standard';
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 { TableBuilderColumnProps as TableBuilderColumnProps_2 } from 'baseui/table-semantic/types';
import { TableBuilderProps as TableBuilderProps_2 } from 'baseui/table-semantic/types';
import { TableOverrides } from 'baseui/table-semantic';
import { TableProps as TableProps_2 } 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 type { TimeChartOptions } from 'lightweight-charts';
import type { TimeRangeChangeEventHandler } from 'lightweight-charts';
import type { TimeScaleOptions as TimeScaleOptions_2 } 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 = AccordionProps_2;

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

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<ButtonProps_2, "kind" | "shape" | "size"> & {
    size?: BUTTON_SIZE;
    disabled?: boolean;
    isLoading?: boolean;
    className?: string;
    role?: AriaRole;
};

export declare const ButtonIcon: ForwardRefExoticComponent<Omit<ButtonProps, "size" | "colors" | "endEnhancer" | "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 CandlestickSeries: ({ children, ...rest }: SeriesProps<"Candlestick">) => JSX_2.Element;

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 Chart: ForwardRefExoticComponent<{
    children?: ReactNode;
    className?: string | undefined;
} & {
    onClick?: MouseEventHandler<Time> | undefined;
    onCrosshairMove?: MouseEventHandler<Time> | undefined;
    onInit?: ChartInitHandler | undefined;
} & DeepPartial<TimeChartOptions> & RefAttributes<HTMLDivElement>>;

export declare type ChartApiRef = {
    _chart: IChartApi | null;
    api: () => IChartApi | null;
    clear: () => void;
    destroyed: boolean;
};

export declare const ChartIcon: NamedExoticComponent<IconProps>;

export declare type ChartInitHandler = (chart: IChartApi) => void;

export declare type ChartOptions = {
    onClick?: MouseEventHandler<Time>;
    onCrosshairMove?: MouseEventHandler<Time>;
    onInit?: ChartInitHandler;
} & DeepPartial<ChartOptions_2>;

export declare type ChartProps = {
    children?: ReactNode;
    className?: string;
} & ChartOptions;

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 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 const CodeField: ForwardRefExoticComponent<{
    code: string;
    extensions?: ReactCodeMirrorProps["extensions"];
    themeOverrides?: Partial<CreateThemeOptions_2> | undefined;
    displayCopy?: boolean | undefined;
    onCopy?: ((code: string, isCopied: boolean) => void) | undefined;
    transformOnCopy?: ((code: string) => string) | undefined;
    showLineNumbers?: boolean | undefined;
    className?: string | undefined;
    editable?: ReactCodeMirrorProps["editable"];
    readOnly?: ReactCodeMirrorProps["readOnly"];
    onChange?: ReactCodeMirrorProps["onChange"];
} & HTMLAttributes<HTMLDivElement> & RefAttributes<HTMLDivElement>>;

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

export declare const CodeIcon: NamedExoticComponent<IconProps>;

export declare const CompleteIcon: NamedExoticComponent<IconProps>;

export declare const CopyIcon: NamedExoticComponent<IconProps>;

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 DefaultFonts = {
    defaultRegularFont: string;
    defaultSemiBoldFont: string;
    defaultMonoRegularFont: string;
    defaultMediumFont: string;
};

export declare const DiscordIcon: NamedExoticComponent<IconProps>;

export declare const DotsIcon: NamedExoticComponent<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 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;
};

export declare const getTableOverrides: () => TableOverrides;

export declare const GithubIcon: NamedExoticComponent<IconProps>;

export declare const HeartIcon: NamedExoticComponent<IconProps>;

export declare const HistogramSeries: ({ children, ...rest }: SeriesProps<"Histogram">) => JSX_2.Element;

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 { LABEL_PLACEMENT as CHECKBOX_LABEL_PLACEMENT }
export { LABEL_PLACEMENT as TOGGLE_LABEL_PLACEMENT }

export declare const LineSeries: ({ children, ...rest }: SeriesProps<"Line">) => JSX_2.Element;

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 MenuIcon: NamedExoticComponent<IconProps>;

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 ModalButton: FC<ModalButtonProps>;

export declare type ModalButtonProps = RegularButtonProps;

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;
    isSelected?: 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 const Panel: FC<PanelProps>;

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

export declare const PlusIcon: NamedExoticComponent<IconProps>;

export declare const PriceLine: ForwardRefExoticComponent<PriceLineProps & RefAttributes<PriceLineApiRef>>;

export declare type PriceLineApiRef = {
    _priceLine: IPriceLine | null;
    api: () => IPriceLine | null;
    clear: () => void;
};

export declare type PriceLineProps = {
    price: number;
    options?: Omit<Partial<PriceLineOptions>, "price">;
};

export declare const PriceScale: ForwardRefExoticComponent<PriceScaleProps & RefAttributes<PriceScaleApiRef>>;

export declare type PriceScaleApiRef = {
    _priceScale: IPriceScaleApi | null;
    api: () => IPriceScaleApi | null;
    setId: (id: string) => void;
    clear: () => void;
};

export declare const priceScaleDefaultOptions: {
    borderVisible: false;
    scaleMargins: {
        top: number;
        bottom: number;
    };
    minimumWidth: number;
};

export declare type PriceScaleOptions = DeepPartial<PriceScaleOptions_2>;

export declare type PriceScaleProps = {
    options?: PriceScaleOptions;
    id: string;
};

export declare const PRIMITIVE_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 white: "#F1F1F1";
    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";
    readonly mono600: "#292929";
};

export declare const ProfileIcon: NamedExoticComponent<IconProps>;

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

export declare const ProgressBar: NamedExoticComponent<never>;

export declare type ProgressBarProps = Omit<ProgressBarProps_2, "steps"> & {
    size?: PROGRESS_BAR_SIZE;
    className?: string;
};

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 = {
    kind?: Exclude<BUTTON_KIND, BUTTON_KIND.toggle>;
} & ButtonCommonProps;

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 SeriesApiRef<T extends SeriesType> = {
    _series: ISeriesApi<T> | null;
    api: () => ISeriesApi<T> | null;
    clear: () => void;
    destroyed: boolean;
};

export declare type SeriesOptions<T extends SeriesType> = SeriesPartialOptionsMap[T];

export declare type SeriesParameters<T extends SeriesType> = {
    data: SeriesDataItemTypeMap[T][];
    markers?: SeriesMarker<Time>[];
    reactive?: boolean;
    options?: SeriesOptions<T>;
};

export declare type SeriesProps<T extends SeriesType> = Omit<SeriesTemplateProps<T>, "type">;

export declare type SeriesTemplateProps<T extends SeriesType> = {
    type: T;
    children?: ReactNode;
} & SeriesParameters<T>;

export declare type SeriesType = Extract<SeriesType_2, "Line" | "Candlestick" | "Histogram">;

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: React_2.NamedExoticComponent<SpinnerProps>;

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

export declare type SpinnerProps = {
    size?: SPINNER_SIZE;
    label?: React_2.ReactNode;
    animation?: boolean;
    color?: string;
    className?: string;
};

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

export declare type StatefulTooltipProps = StatefulTooltipProps_2 & TooltipCommonProps;

export { StyledAction }

export { StyledBody }

export { StyledContents }

export { StyledHeaderImage }

export { StyledRoot }

export { StyledThumbnail }

export { StyledTitle }

export { StyledWrapper }

export declare const svgInlineDotsPattern: string;

export declare const Tab: FC<TabProps>;

export declare const Table: FC<TableProps>;

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 TableBuilder: FC<TableBuilderProps>;

export declare const TableBuilderColumn: FC<TableBuilderColumnProps>;

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

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

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

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

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 TimeScale: ForwardRefExoticComponent<TimeScaleProps & RefAttributes<TimeScaleApiRef>>;

export declare type TimeScaleApiRef = {
    _timeScale: ITimeScaleApi<Time> | null;
    api: () => ITimeScaleApi<Time> | null;
    clear: () => void;
};

export declare type TimeScaleOptions = DeepPartial<TimeScaleOptions_2>;

export declare type TimeScaleProps = {
    onVisibleTimeRangeChange?: TimeRangeChangeEventHandler<Time>;
    onVisibleLogicalRangeChange?: LogicalRangeChangeEventHandler;
    onSizeChange?: SizeChangeEventHandler;
    visibleRange?: Range_2<Time>;
    visibleLogicalRange?: Range_2<number>;
    options?: TimeScaleOptions;
};

export declare const Toggle: FC<ToggleProps>;

export declare type ToggleButtonProps = {
    kind: BUTTON_KIND.toggle;
    checked?: boolean;
} & ButtonCommonProps;

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