import React$1, { ElementType, HTMLAttributes, Key, CSSProperties, ReactNode, ButtonHTMLAttributes, AllHTMLAttributes, ReactElement } from 'react';
import { ColumnType, TableProps as TableProps$1 } from 'rc-table';
import { GetRowKey } from 'rc-table/lib/interface';

interface AccordionProps extends Omit<React.AllHTMLAttributes<HTMLDivElement>, 'summary'> {
    children?: React.ReactNode;
    summary?: React.ReactNode;
    actions?: React.ReactNode;
    className?: string;
    summaryClassName?: string;
    actionsClassName?: string;
    containerClassName?: string;
    expanded?: boolean;
    onExpand?: () => void;
    defaultExpanded?: boolean;
    disabled?: boolean;
    icon?: React.ReactNode;
    unmountOnExit?: boolean;
    variant?: 'drawer' | 'individual';
}

declare const Accordion: React$1.ForwardRefExoticComponent<AccordionProps & React$1.RefAttributes<HTMLDivElement>>;

type AlertSeverity = 'success' | 'info' | 'warning' | 'error';
type AlertVariant = 'default' | 'filled' | 'outlined';
interface AlertProps extends React.AllHTMLAttributes<HTMLDivElement> {
    severity?: AlertSeverity;
    variant?: AlertVariant;
    color?: AlertSeverity | 'inherit';
    actionElement?: React.ReactNode;
    icon?: React.ReactNode;
    alertTitle?: string | boolean;
    open?: boolean;
    children?: React.ReactNode;
    iconClassName?: string;
    bodyClassName?: string;
    titleClassName?: string;
    textClassName?: string;
}

declare const Alert: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;

interface AvatarProps extends Omit<React.AllHTMLAttributes<HTMLDivElement>, 'size'> {
    picture?: string;
    chars?: string;
    size?: 'small' | 'medium' | 'large';
    variant?: 'circular' | 'square';
    defaultPicture?: string;
    className?: string;
    Component?: ElementType;
    componentProps?: Record<string, unknown>;
}

declare const Avatar: React$1.ForwardRefExoticComponent<AvatarProps & React$1.RefAttributes<HTMLDivElement>>;

type BadgeColor = 'primary' | 'secondary' | 'success' | 'error';
type BadgeVariant = 'default' | 'dot';
type VerticalPosition = 'top' | 'bottom';
type HorizontalPosition = 'start' | 'end';
type BadgePosition = `${VerticalPosition}-${HorizontalPosition}` | VerticalPosition | HorizontalPosition;
interface BadgeProps extends Omit<React.AllHTMLAttributes<HTMLDivElement>, 'content'> {
    children: React.ReactNode;
    content: React.ReactNode;
    color?: BadgeColor;
    variant?: BadgeVariant;
    position?: BadgePosition;
    invisible?: boolean;
    containerClassName?: string;
}

declare const Badge: React$1.ForwardRefExoticComponent<BadgeProps & React$1.RefAttributes<HTMLDivElement>>;

interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
    children: React.ReactNode;
    className?: string;
    disabled?: boolean;
    loading?: boolean;
    color?: 'primary' | 'secondary' | 'destructive';
    variant?: 'default' | 'link' | 'outline' | 'ghost';
    size?: 'icon' | 'small' | 'medium' | 'large';
    fluid?: boolean;
    type?: 'submit' | 'reset' | 'button';
}

declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

interface CardProps {
    title?: string | React.ReactNode;
    description?: string | React.ReactNode;
    collapsible?: boolean;
    size?: 'small' | 'medium' | 'large';
    fluid?: boolean;
    className?: string;
    children: React.ReactNode;
}

declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;

interface BentoCardProps extends React.AllHTMLAttributes<HTMLDivElement> {
    rootClassName?: string;
    rootActiveClassName?: string;
    title?: string;
    titleActiveClassName?: string;
    titleClassName?: string;
    buttonClassName?: string;
    activeButtonClassName?: string;
    isTitleVisibleInFirst?: boolean;
    isTitleVisibleInSecond?: boolean;
    firstContent?: React.ReactNode | string;
    secondContent?: React.ReactNode | string;
    redirectTo?: string;
}

declare const BentoCard: React$1.ForwardRefExoticComponent<BentoCardProps & React$1.RefAttributes<HTMLDivElement>>;

interface ChipProps extends React.AllHTMLAttributes<HTMLSpanElement> {
    children: string;
    color?: 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error';
}

declare const Chip: React$1.ForwardRefExoticComponent<ChipProps & React$1.RefAttributes<HTMLSpanElement>>;

interface BentoItem {
    element: React$1.ReactNode;
    width: number;
    height: number;
}
type BentoItems = BentoItem[];
interface BentoGridProps extends React$1.AllHTMLAttributes<HTMLDivElement> {
    items: BentoItems;
    gridCols?: number;
    rowHeight?: number;
}

declare const BentoGrid: React$1.ForwardRefExoticComponent<BentoGridProps & React$1.RefAttributes<HTMLDivElement>>;

interface ResponsiveGridValues {
    base: number;
    sm?: number;
    md?: number;
    lg?: number;
    xl?: number;
    xxl?: number;
}
interface GridProps extends HTMLAttributes<HTMLDivElement> {
    container?: boolean;
    span?: number | ResponsiveGridValues;
    columns?: number | ResponsiveGridValues;
    padding?: number | ResponsiveGridValues;
    gap?: number | ResponsiveGridValues;
    rowGap?: number | ResponsiveGridValues;
    columnGap?: number | ResponsiveGridValues;
}

declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;

type Type = 'withSeparator' | 'withLabels' | 'labelsUnder' | 'inBoxes' | 'default';
interface CountdownProps extends React.AllHTMLAttributes<HTMLDivElement> {
    date: Date | number;
    showDay?: boolean;
    showHour?: boolean;
    showMinute?: boolean;
    showSecond?: boolean;
    type?: Type;
    itemClassName?: string;
    rootClassName?: string;
    valueClassName?: string;
    labelClassName?: string;
}

declare const Countdown: React$1.ForwardRefExoticComponent<CountdownProps & React$1.RefAttributes<HTMLDivElement>>;

interface DataTableI18N {
    pagination: {
        rows: string;
        of: string;
        previous: string;
        next: string;
    };
    filter: {
        reset: string;
        columns: string;
        operator: string;
        selectOperator: string;
        typeValue: string;
        notNeeded: string;
        contains: string;
        doesNotContain: string;
        equals: string;
        doesNotEqual: string;
        startsWith: string;
        endsWith: string;
        isEmpty: string;
        isNotEmpty: string;
        isAnyOf: string;
    };
}
interface DataItem$1 {
    key?: Key;
    [key: string]: unknown;
}
interface DataTableColumn<T> extends ColumnType<T> {
    filterable?: boolean;
}
interface DataTableProps<T> {
    data: T[];
    columns: DataTableColumn<T>[];
    rowsPerPage?: number;
    pagination?: boolean;
    rowsPerPageOptions?: number[];
    border?: boolean;
    rowSelect?: boolean;
    rowSelectAction?: (selectedRows: (string | number)[]) => void;
    checkboxAvailable?: boolean;
    title?: React.ReactNode | string;
    filter?: boolean;
    virtualized?: boolean;
    emptyText?: React.ReactNode;
    rowClassName?: string;
    maxHeight?: number;
    minHeight?: number;
    sorting?: boolean;
    i18n?: Partial<DataTableI18N>;
}

declare const DataTable: React$1.ForwardRefExoticComponent<DataTableProps<DataItem$1> & React$1.RefAttributes<HTMLDivElement>>;

interface DividerProps extends React.HTMLAttributes<HTMLDivElement> {
    variant?: 'full' | 'start' | 'center' | 'end';
    orientation?: 'horizontal' | 'vertical';
    align?: 'start' | 'center' | 'end';
    color?: string;
    size?: `${string}px` | `${string}rem`;
    round?: boolean;
}

declare const Divider: React$1.ForwardRefExoticComponent<DividerProps & React$1.RefAttributes<HTMLDivElement>>;

interface ListProps {
    children: React.ReactNode;
    className?: string;
}
interface ListItemProps {
    children: React.ReactNode;
    className?: string;
}
interface ListItemButtonProps {
    children: React.ReactNode;
    onClick?: () => void;
    className?: string;
}
interface ListItemIconProps {
    icon: React.ReactNode;
    className?: string;
}
interface ListItemSubtitleProps {
    subtitle: string;
    className?: string;
}
interface ListDividerProps {
    className?: string;
}
interface ListSubheaderProps {
    children: React.ReactNode;
    className?: string;
}

declare const List: React$1.ForwardRefExoticComponent<ListProps & React$1.RefAttributes<HTMLUListElement>>;
declare const ListItem: {
    ({ children, className }: ListItemProps): React$1.JSX.Element;
    displayName: string;
};
declare const ListItemButton: {
    ({ children, onClick, className, }: ListItemButtonProps): React$1.JSX.Element;
    displayName: string;
};
declare const ListItemIcon: {
    ({ icon, className }: ListItemIconProps): React$1.JSX.Element;
    displayName: string;
};
declare const ListItemSubtitle: {
    ({ subtitle, className, }: ListItemSubtitleProps): React$1.JSX.Element;
    displayName: string;
};
declare const ListDivider: {
    ({ className }: ListDividerProps): React$1.JSX.Element;
    displayName: string;
};
declare const ListSubheader: {
    ({ children, className, }: ListSubheaderProps): React$1.JSX.Element;
    displayName: string;
};

interface ProgressProps extends React.SVGAttributes<SVGSVGElement> {
    value?: number;
    max?: number;
    min?: number;
    size?: number;
    trackSize?: number;
    variant?: 'linear' | 'circular';
    color?: 'default' | 'success' | 'info' | 'warning' | 'error';
    progressLabel?: boolean;
    determinate?: boolean;
    className?: string;
    containerClassName?: string;
    trackClassName?: string;
    progressClassName?: string;
    labelClassName?: string;
}

declare const Progress: React$1.ForwardRefExoticComponent<ProgressProps & React$1.RefAttributes<SVGSVGElement>>;

type ScrollOrientation = 'vertical' | 'horizontal';
interface ScrollAreaProps extends React.AllHTMLAttributes<HTMLDivElement> {
    orientation: ScrollOrientation;
    className?: string;
    style?: CSSProperties;
    children?: React.ReactNode;
}

declare const ScrollArea: React$1.ForwardRefExoticComponent<ScrollAreaProps & React$1.RefAttributes<HTMLDivElement>>;

interface SkeletonAvatarProps extends Omit<React.AllHTMLAttributes<HTMLDivElement>, 'size'> {
    size?: string;
}
interface SkeletonButtonProps extends React.AllHTMLAttributes<HTMLDivElement> {
    width?: string;
    height?: string;
}
interface SkeletonCardProps extends React.AllHTMLAttributes<HTMLDivElement> {
    width?: string;
    height?: string;
}
interface SkeletonImageProps extends React.AllHTMLAttributes<HTMLDivElement> {
    width?: string;
    height?: string;
}
interface SkeletonInputProps extends React.AllHTMLAttributes<HTMLDivElement> {
    width?: string;
    height?: string;
}
interface SkeletonListProps extends React.AllHTMLAttributes<HTMLDivElement> {
    itemCount?: number;
}
interface SkeletonParagraphProps extends React.AllHTMLAttributes<HTMLDivElement> {
    lines?: number;
}
interface SkeletonTableProps extends React.AllHTMLAttributes<HTMLDivElement> {
    rows?: number;
    columns?: number;
}

declare const SkeletonAvatar: React$1.FC<SkeletonAvatarProps>;

declare const SkeletonButton: React$1.FC<SkeletonButtonProps>;

declare const SkeletonParagraph: React$1.FC<SkeletonParagraphProps>;

declare const SkeletonTable: React$1.FC<SkeletonTableProps>;

declare const SkeletonCard: React$1.FC<SkeletonCardProps>;

declare const SkeletonList: React$1.FC<SkeletonListProps>;

declare const SkeletonImage: React$1.FC<SkeletonImageProps>;

declare const SkeletonInput: React$1.FC<SkeletonInputProps>;

interface StepperProps {
    steps: {
        label: string;
        optional?: boolean;
        icon?: React.ReactNode;
        content?: React.ReactNode;
    }[];
    direction?: 'horizontal' | 'vertical';
    color?: 'primary' | 'secondary';
    className?: string;
}
interface StepProps {
    children: React.ReactNode;
    active: boolean;
    completed: boolean;
    color?: 'primary' | 'secondary';
    className?: string;
}
interface StepLabelProps {
    label: string;
    optional?: boolean;
    active: boolean;
    completed: boolean;
    color?: 'primary' | 'secondary';
    className?: string;
}
interface StepIconProps {
    icon: React.ReactNode;
    active: boolean;
    completed: boolean;
    color?: 'primary' | 'secondary';
    className?: string;
}
interface StepConnectorProps {
    active: boolean;
    completed: boolean;
    color?: 'primary' | 'secondary';
    className?: string;
}

declare const Stepper: React$1.ForwardRefExoticComponent<StepperProps & React$1.RefAttributes<HTMLDivElement>>;
declare const Step: {
    ({ children, active, completed, color, className, }: StepProps): React$1.JSX.Element;
    displayName: string;
};
declare const StepLabel: {
    ({ label, optional, active, completed, color, className, }: StepLabelProps): React$1.JSX.Element;
    displayName: string;
};
declare const StepIcon: {
    ({ icon, active, completed, color, className, }: StepIconProps): React$1.JSX.Element;
    displayName: string;
};
declare const StepConnector: {
    ({ active, completed, color, className, }: StepConnectorProps): React$1.JSX.Element;
    displayName: string;
};

interface TabType {
    button: React.ReactNode;
    content: React.ReactNode;
    disabled?: boolean;
    open?: boolean;
}
interface TabProps extends React.AllHTMLAttributes<HTMLDivElement> {
    tabs: TabType[];
    className?: string;
    buttonsClassName?: string;
    contentClassName?: string;
    variant?: 'default' | 'tab';
}

declare const Tab: React$1.ForwardRefExoticComponent<TabProps & React$1.RefAttributes<HTMLDivElement>>;

interface DataItem {
    key?: Key;
    [key: string]: unknown;
}
interface TableProps<T extends DataItem = DataItem> extends TableProps$1 {
    data?: T[];
    columns: ColumnType<T>[];
    rowClassName?: string | ((record: T) => string);
    emptyText?: ReactNode;
    summary?: (data: readonly T[]) => ReactNode;
    style?: CSSProperties;
    virtualized?: boolean;
    border?: boolean;
    rowKey?: string | number | keyof T | GetRowKey<T>;
}

declare const Table: <T extends DataItem>({ data, columns, rowClassName, emptyText, virtualized, border, ...rest }: TableProps<T>) => React$1.JSX.Element;

interface ToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onToggle'> {
    initialState?: boolean;
    onToggle?: (state: boolean) => void;
    color?: 'primary' | 'secondary' | 'destructive';
    variant?: 'default' | 'outline';
    size?: 'small' | 'medium' | 'large';
    fluid?: boolean;
    className?: string;
    disabled?: boolean;
    children?: ReactNode;
}

declare const Toggle: React$1.ForwardRefExoticComponent<ToggleProps & React$1.RefAttributes<HTMLButtonElement>>;

interface ToggleItemProps {
    value: string;
    initialState?: boolean;
    onToggle?: (toggled: boolean) => void;
    color?: 'primary' | 'secondary' | 'destructive';
    variant?: 'default' | 'outline';
    size?: 'small' | 'medium' | 'large';
    fluid?: boolean;
    className?: string;
    disabled?: boolean;
    children?: ReactNode;
}
interface ToggleWrapperProps {
    value: string | null;
    onChange: (value: string) => void;
    children: ReactNode | ReactNode[];
    direction?: 'horizontal' | 'vertical';
}

declare const ToggleGroup: {
    ToggleWrapper: React$1.ForwardRefExoticComponent<ToggleWrapperProps & React$1.RefAttributes<HTMLDivElement>>;
    ToggleItem: {
        ({ value, initialState, onToggle, color, variant, size, fluid, className, disabled, children, ...props }: ToggleItemProps): React$1.JSX.Element;
        displayName: string;
    };
};

interface TooltipProps extends AllHTMLAttributes<HTMLElement> {
    text: string;
    open?: boolean;
    placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
    trigger?: 'hover' | 'click';
    className?: string;
    spacing?: number;
    hideArrow?: boolean;
    openDelay?: boolean | number;
    closeDelay?: boolean;
    clickToClose?: boolean;
    children: ReactElement;
}

declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLElement>>;

interface PopoverProps extends AllHTMLAttributes<HTMLElement> {
    popper: ReactElement;
    open?: boolean;
    placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
    trigger?: 'click' | 'hover';
    className?: string;
    spacing?: number;
    hideArrow?: boolean;
    openDelay?: boolean | number;
    closeDelay?: boolean | number;
    clickToClose?: boolean;
    children: ReactElement;
}

declare const Popover: React$1.ForwardRefExoticComponent<PopoverProps & React$1.RefAttributes<HTMLElement>>;

interface DropdownProps extends Omit<AllHTMLAttributes<HTMLDivElement>, 'onFocus'> {
    children: ReactElement | ReactElement[];
    component?: ReactElement;
    label?: string;
    className?: string;
    menuClassName?: string;
    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
    icon?: ReactElement;
    placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
}

declare const Dropdown: React$1.ForwardRefExoticComponent<DropdownProps & React$1.RefAttributes<HTMLDivElement>>;

interface ContextMenuProps extends Omit<React.AllHTMLAttributes<HTMLDivElement>, 'label'> {
    children: ReactElement | ReactElement[];
    component?: ReactElement;
    label?: ReactElement | ReactElement[] | string;
    className?: string;
    menuClassName?: string;
    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
}

declare const ContextMenu: React$1.ForwardRefExoticComponent<ContextMenuProps & React$1.RefAttributes<HTMLDivElement>>;

interface FloatingMenuItemProps {
    label: string | React.ReactNode;
    className?: string;
    disabled?: boolean;
    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
}

declare const FloatingMenuItem: React$1.ForwardRefExoticComponent<FloatingMenuItemProps & React$1.RefAttributes<HTMLDivElement>>;

type TypographySize = 'small' | 'medium' | 'large' | 'lead';
type TypographyColor = 'default' | 'info' | 'warning' | 'error' | 'success';
type TypographyDecoration = 'underline' | 'overline' | 'linethrough';
type TypographyElement = 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
interface BaseTypographyProps extends Omit<AllHTMLAttributes<HTMLElement>, 'size'> {
    color?: TypographyColor;
    decoration?: TypographyDecoration;
    italic?: boolean;
    bold?: boolean;
    gradient?: boolean;
    children: ReactNode;
    className?: string;
}
interface TitleProps extends BaseTypographyProps {
    size?: TypographySize;
}
interface SubtitleProps extends BaseTypographyProps {
    elementType?: TypographyElement;
}
interface ParagraphProps extends BaseTypographyProps {
    size?: TypographySize;
}
interface MutedProps extends BaseTypographyProps {
    size?: TypographySize;
}
interface QuoteProps extends BaseTypographyProps {
    size?: TypographySize;
}
type CombinedTypographyProps = TitleProps & SubtitleProps & ParagraphProps & MutedProps & QuoteProps;
type TypographyVariant = 'title' | 'subtitle' | 'paragraph' | 'muted' | 'quote';
interface TypographyProps extends CombinedTypographyProps {
    variant: TypographyVariant;
}

declare const Typography: React$1.ForwardRefExoticComponent<TypographyProps & React$1.RefAttributes<HTMLElement>>;

interface WordAnimationProps {
    text: string;
    className?: string;
    wordClassName?: string;
}

declare const WordAnimation: React$1.FC<WordAnimationProps>;

interface BreadcrumbData {
    label: string;
    icon?: React.ReactNode;
    href?: string;
}
interface BreadcrumbsProps {
    data: BreadcrumbData[];
    separator?: string;
    className?: string;
    activeClassName?: string;
    listClassName?: string;
    itemClassName?: string;
}

declare const Breadcrumbs: React$1.FC<BreadcrumbsProps>;

export { Accordion, type AccordionProps, Alert, type AlertProps, Avatar, type AvatarProps, Badge, type BadgeProps, BentoCard, type BentoCardProps, BentoGrid, type BentoGridProps, type BentoItems, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, Card, type CardProps, Chip, type ChipProps, ContextMenu, type ContextMenuProps, Countdown, type CountdownProps, DataTable, type DataTableProps, Divider, type DividerProps, Dropdown, type DropdownProps, FloatingMenuItem, type FloatingMenuItemProps, Grid, type GridProps, List, ListDivider, type ListDividerProps, ListItem, ListItemButton, type ListItemButtonProps, ListItemIcon, type ListItemIconProps, type ListItemProps, ListItemSubtitle, type ListItemSubtitleProps, type ListProps, ListSubheader, type ListSubheaderProps, Popover, type PopoverProps, Progress, type ProgressProps, ScrollArea, type ScrollAreaProps, SkeletonAvatar, type SkeletonAvatarProps, SkeletonButton, type SkeletonButtonProps, SkeletonCard, type SkeletonCardProps, SkeletonImage, type SkeletonImageProps, SkeletonInput, type SkeletonInputProps, SkeletonList, type SkeletonListProps, SkeletonParagraph, type SkeletonParagraphProps, SkeletonTable, type SkeletonTableProps, Step, StepConnector, type StepConnectorProps, StepIcon, type StepIconProps, StepLabel, type StepLabelProps, type StepProps, Stepper, type StepperProps, Tab, type TabProps, Table, type TableProps, Toggle, ToggleGroup, type ToggleItemProps, type ToggleProps, type ToggleWrapperProps, Tooltip, type TooltipProps, Typography, type TypographyProps, WordAnimation, type WordAnimationProps };