import * as React$1 from 'react';
import React__default, { ButtonHTMLAttributes, ReactNode, FC, HTMLAttributes, DetailedHTMLProps, InputHTMLAttributes, ChangeEvent, KeyboardEvent, SVGProps, TextareaHTMLAttributes, ComponentProps } from 'react';
import * as _mui_material from '@mui/material';
import { BadgeProps, SkeletonProps, Theme } from '@mui/material';
import { PopoverProps } from '@mui/material/Popover';
import { CircularProgressProps } from '@mui/material/CircularProgress';
export { default as ButtonBaseComponent } from '@mui/material/ButtonBase';
import { Props } from 'react-select';
import { SwitchProps } from '@mui/material/Switch';
import { UsePaginationProps, UsePaginationItem } from '@mui/material/usePagination/usePagination';
import { TooltipProps } from '@mui/material/Tooltip';
import * as _emotion_styled from '@emotion/styled';
import * as _mui_system from '@mui/system';
import { GaugeProps } from '@mui/x-charts/Gauge';
import { DateCalendarProps } from '@mui/x-date-pickers';
import Cascader, { CascaderProps } from 'rc-cascader';

interface IColorAmount {
    25?: string;
    50?: string;
    100?: string;
    200?: string;
    300?: string;
    400?: string;
    500?: string;
    600?: string;
    700?: string;
    800?: string;
    900?: string;
    950?: string;
}
type ColorAmountType = 25 | 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;

type ColorsNameType = 'primary' | 'error' | 'warning' | 'success' | 'gray' | 'grayBlue' | 'grayCool' | 'grayModern' | 'grayNeutral' | 'grayIron' | 'grayTrue' | 'grayWarm' | 'moss' | 'greenLight' | 'green' | 'teal' | 'cyan' | 'blueLight' | 'blue' | 'blueDark' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose' | 'orangeDark' | 'orange' | 'yellow';
interface IColorsName {
    typography: IColorAmount;
    primary: IColorAmount;
    error: IColorAmount;
    warning: IColorAmount;
    success: IColorAmount;
    gray: IColorAmount;
    grayBlue: IColorAmount;
    grayCool: IColorAmount;
    grayModern: IColorAmount;
    grayNeutral: IColorAmount;
    grayIron: IColorAmount;
    grayTrue: IColorAmount;
    grayWarm: IColorAmount;
    moss: IColorAmount;
    greenLight: IColorAmount;
    green: IColorAmount;
    teal: IColorAmount;
    cyan: IColorAmount;
    blueLight: IColorAmount;
    blue: IColorAmount;
    blueDark: IColorAmount;
    indigo: IColorAmount;
    violet: IColorAmount;
    purple: IColorAmount;
    fuchsia: IColorAmount;
    pink: IColorAmount;
    rose: IColorAmount;
    orangeDark: IColorAmount;
    orange: IColorAmount;
    yellow: IColorAmount;
    black: string;
    white: string;
    border: IColorAmount;
    shadow: IColorAmount;
    digikala: IColorAmount;
}
interface IOverrideColors {
    primary: true;
    error: true;
    warning: true;
    success: true;
    gray: true;
    grayBlue: true;
    grayCool: true;
    grayModern: true;
    grayNeutral: true;
    grayIron: true;
    grayTrue: true;
    grayWarm: true;
    moss: true;
    greenLight: true;
    green: true;
    teal: true;
    cyan: true;
    blueLight: true;
    blue: true;
    blueDark: true;
    indigo: true;
    violet: true;
    purple: true;
    fuchsia: true;
    pink: true;
    rose: true;
    orangeDark: true;
    orange: true;
    yellow: true;
    secondary: false;
    info: false;
    digikala: true;
}

type ButtonVariantsType = 'contained' | 'pale' | 'text' | 'link' | 'outlined';
type ButtonSizesType = 'sm' | 'md' | 'lg' | 'xl';
type ButtonColorsType = ColorsNameType;
interface IButton extends ButtonHTMLAttributes<HTMLButtonElement> {
    disabled?: boolean;
    children?: ReactNode;
    size?: ButtonSizesType;
    variant?: ButtonVariantsType;
    color?: ButtonColorsType;
    isLoading?: boolean;
    loadingContent?: ReactNode;
    aspectRatio?: string;
    fontSize?: string;
}

/**
 * ButtonComponent is a reusable React component that renders a button element with customizable styles and behaviors.
 * @version 0.0.3
 * @author Ali M. Sadeghi
 */
declare const ButtonComponent: FC<IButton>;

type TypographySizesType = 'display2XL' | 'displayXL' | 'displayLG' | 'displayMD' | 'displaySM' | 'displayXS' | 'textXL' | 'textLG' | 'textMD' | 'textSM' | 'textXS' | 'textXXS';
type TypographyWeights = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
interface ITypographyTags {
    h1: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h2: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h3: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h4: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h5: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    h6: DetailedHTMLProps<HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>;
    p: DetailedHTMLProps<HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>;
    small: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    span: DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
    strong: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
    b: DetailedHTMLProps<HTMLAttributes<HTMLElement>, HTMLElement>;
}
interface ITypography extends HTMLAttributes<HTMLDivElement> {
    tag?: keyof ITypographyTags;
    color?: ColorsNameType;
    size?: TypographySizesType;
    weight?: TypographyWeights;
    children?: ReactNode;
    ref?: React.LegacyRef<HTMLSpanElement> | undefined;
    contentWrapper?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>;
}

declare const TypographyComponent: FC<ITypography>;

type BadgeVariantsType = 'modern' | 'outlined' | 'contained';
type BadgeSizesType = 'sm' | 'md' | 'lg';
type BadgeRoundsType = 'sm' | '2xl';
type BadgeColorsType = ColorsNameType;
interface IBadge {
    variant?: BadgeVariantsType;
    size?: BadgeSizesType;
    round?: BadgeRoundsType;
    color?: BadgeColorsType;
    startIcon?: ReactNode;
    endIcon?: ReactNode;
    jsxElement?: ReactNode;
    dotIcon?: boolean;
    closeIcon?: {
        props?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
        show: boolean;
    };
    avatar?: string;
    text?: string;
    className?: string;
}
interface IBadgeIcon {
    color: ColorsNameType;
}

declare const BadgeComponent: FC<IBadge>;

interface ISignal extends BadgeProps {
}

/**
 *
 * @author Ali M. Sadeghi
 * @version 0.0.1
 *
 */
declare const SignalComponent: FC<ISignal>;

type DotVariantsType = 'fill' | 'radiate' | 'outline';
type DotSizesType = 'sm' | 'md' | 'lg';
type DotColorsType = ColorsNameType;
interface IDot extends HTMLAttributes<HTMLSpanElement> {
    children?: ReactNode;
    size?: DotSizesType;
    variant?: DotVariantsType;
    color?: DotColorsType;
}

/**
 * DotComponent is a reusable React component that renders a dot element.
 * @version 0.0.3
 */
declare const DotComponent: FC<IDot>;

type CheckboxSizesType = 'xs' | 'sm' | 'md';
type CheckboxColorsType = ColorsNameType;
interface ICheckbox extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
    size?: CheckboxSizesType;
    disabled?: boolean;
    title?: string;
    hint?: string;
    indeterminate?: boolean;
    checked?: boolean;
    color?: CheckboxColorsType;
}
interface ICheckboxFrame extends HTMLAttributes<HTMLDivElement> {
    size?: 'extra-small' | 'small' | 'medium';
    checked?: boolean;
    disabled?: boolean;
    color?: CheckboxColorsType;
}
interface ICheckboxSizeMapper {
    xs: 'extra-small';
    sm: 'small';
    md: 'medium';
}

declare const CheckboxComponent: FC<ICheckbox>;

type RadioSizesType = 'xs' | 'sm' | 'md';
type RadioColorsType = ColorsNameType;
interface IRadio extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
    size?: RadioSizesType;
    disabled?: boolean;
    title?: string;
    hint?: string;
    checked?: boolean;
    color?: RadioColorsType;
    id?: string;
    hoverable?: boolean;
}
interface IRadioFrame extends HTMLAttributes<HTMLDivElement> {
    size?: 'extra-small' | 'small' | 'medium';
    checked?: boolean;
    disabled?: boolean;
    color?: RadioColorsType;
    hoverable?: boolean;
}
interface IRadioSizeMapper {
    xs: 'extra-small';
    sm: 'small';
    md: 'medium';
}

declare const RadioComponent: FC<IRadio>;

interface IRedStar extends ITypography {
}

/**
 *
 * @author Ali M. Sadeghi
 * @version 0.0.1
 *
 */
declare const RedStarComponent: FC<IRedStar>;

interface IPopover {
    children: ReactNode;
    triggerElement: ReactNode;
    popover?: Omit<PopoverProps, 'open'>;
    containerClassName?: string;
}

/**
 * PopoverComponent is a reusable React component that renders a popover element with customizable styles and behaviors.
 * @version 0.0.3
 * @author Audrey Bozorgi
 */
declare const PopoverComponent: FC<IPopover>;

interface ISkeleton extends SkeletonProps {
}

declare const SkeletonComponent: FC<ISkeleton>;

declare const CircularProgressComponent: FC<ICircularProgress>;

interface ICircularProgress extends CircularProgressProps {
}

type AlertVariantsType = 'primary' | 'secondary' | 'danger' | 'warning' | 'success';
interface IAlert {
    hasIcon?: boolean;
    hasDismiss?: boolean;
    variant?: AlertVariantsType;
    children?: ReactNode;
}
interface IAlertSurface {
    color: ColorsNameType;
}
interface IAlertContent {
    hasIcon: boolean;
}
interface IAlertVariantMapper {
    primary: 'primary';
    secondary: 'gray';
    danger: 'error';
    warning: 'warning';
    success: 'success';
}
interface IAlertButtonGroup {
    children: ReactNode;
}
interface IAlertButton extends IButton {
}
interface IAlertText extends Omit<ITypography, 'variant' | 'color'> {
}

declare const Alert: FC<IAlert>;
declare const AlertComponent: React__default.FC<IAlert> & {
    ButtonGroup: React__default.FC<IAlertButtonGroup>;
    PrimaryButton: React__default.FC<Omit<IAlertButton, "color" | "variant">>;
    SecondaryButton: React__default.FC<Omit<IAlertButton, "color" | "variant">>;
    Title: React__default.FC<IAlertText>;
    Description: React__default.FC<IAlertText>;
};

type AvatarSizesType = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
type AvatarStatusesType = 'verified' | 'online' | 'none';
interface IAvatar extends HTMLAttributes<HTMLElement> {
    size?: AvatarSizesType;
    round?: 'full' | `${number}px`;
    border?: boolean;
    src?: string;
    placeholder?: string;
    unlimitedPlaceholder?: boolean;
    status?: AvatarStatusesType;
}

declare const AvatarComponent: React__default.FC<IAvatar>;

type IAvatarGroupSizesType = 'xs' | 'sm' | 'md';
interface IAvatarGroup {
    size?: IAvatarGroupSizesType;
    max?: number;
    data: any[];
    wrapper?: (item: any, children: React.ReactElement) => React.ReactElement;
}

declare const AvatarGroupComponent: FC<IAvatarGroup>;

type AvatarLabelGroupSizesType = 'xs' | 'sm' | 'md' | 'lg';
interface IAvatarLabelGroupContent {
    isTruncated?: boolean;
}
interface IAvatarLabelGroup extends IAvatarLabelGroupContent {
    title: React.ReactNode;
    titleClassName?: string;
    description: React.ReactNode;
    descriptionClassName?: string;
    avatar?: string;
    size?: AvatarLabelGroupSizesType;
}

declare const AvatarLabelGroupComponent: FC<IAvatarLabelGroup>;

type IAvatarProfileSizesType = 'xs' | 'sm' | 'md';
interface IAvatarProfile extends Omit<IAvatar, 'round' | 'size' | 'status'> {
    size?: IAvatarProfileSizesType;
    status?: 'none' | 'verified' | 'online';
}

declare const AvatarProfileComponent: FC<IAvatarProfile>;

interface IFonts {
    fa: {
        iranYekan: {
            normal: string | number;
            faNum: string | number;
        };
    };
    en: {
        inter: {
            normal: string | number;
        };
    };
}

type StartAdornmentComponent = (props: any) => React.ReactNode;
interface IDropdownExtendedControl {
    startAdornment?: React.ReactNode | StartAdornmentComponent;
}

type IDropdownColorType = ColorsNameType;
type IDropdownComponent = Props['components'] & {
    InputStartAdornment?: IDropdownExtendedControl['startAdornment'];
};
interface IDropdown extends Props {
    options?: any[];
    color?: IDropdownColorType;
    extraData?: any;
    menuListHeader?(props: any): React.ReactNode;
    menuListFooter?(props: any): React.ReactNode;
    components?: IDropdownComponent;
}

declare const DropdownComponent: FC<IDropdown>;

type EnterCodeSizesType = 'sm' | 'md' | 'lg';
type EnterCodeColorsType = ColorsNameType;
interface IEnterCode {
    error?: boolean;
    disabled?: boolean;
    fields: number;
    onComplete: (val: string) => void;
    placeholder?: string;
    size?: EnterCodeSizesType;
    label?: string;
    hint?: string;
    color?: EnterCodeColorsType;
}
interface IEnterCodeDescription {
    error?: boolean;
}
interface IEnterCodeWrapper {
    size?: EnterCodeSizesType;
}

declare const EnterCodeComponent: FC<IEnterCode>;

declare const useEnterCode: ({ onComplete, fields }: IEnterCode) => {
    processInput: (e: ChangeEvent<HTMLInputElement>, slot: number) => void;
    onKeyUp: (e: KeyboardEvent<HTMLInputElement>, slot: number) => void;
    code: string[];
    inputs: React$1.MutableRefObject<(HTMLInputElement | null)[]>;
};

type IFormContainerColorType = ColorsNameType;
interface IFormContainer {
    id?: string;
    error?: boolean;
    label?: string;
    hint?: string;
    containerClassName?: string;
    mandatory?: boolean;
    children: React.ReactNode;
}
interface IFormContainerDescription {
    error?: boolean;
}
interface IFormContainerContent {
    error?: boolean;
    color?: IFormContainerColorType;
    disabled?: boolean;
}
interface IFormContainerField {
    error?: boolean;
    color?: IFormContainerColorType;
}

/**
 *
 * @author Sina Shahoveisi
 * @version 0.0.1
 * @description A React component that renders label and description for form validation.
 * @madeUse Emotion
 */
declare const FormContainerComponent: FC<IFormContainer>;

type IInputColorType = ColorsNameType;
interface IInput extends InputHTMLAttributes<HTMLInputElement> {
    id?: string;
    endAdornment?: ReactNode;
    startAdornment?: ReactNode;
    disabled?: boolean;
    error?: boolean;
    label?: string;
    hint?: string;
    containerClassName?: string;
    autoComplete?: 'off' | 'on';
    color?: IInputColorType;
    placeholder?: string;
    mandatory?: boolean;
}
interface IInputDescription {
    error?: boolean;
}
interface IInputContainer {
    error?: boolean;
    color?: IInputColorType;
    disabled?: boolean;
}
interface IInputField {
    error?: boolean;
    color?: IInputColorType;
}

/**
 *
 * @author Ali M. Sadeghi
 * @version 0.0.2
 * @description A React component that renders an input field.
 * @madeUse Emotion
 */
declare const InputComponent: FC<IInput>;

type ProgressBarColorsType = ColorsNameType;
type ProgressBarSizesType = 'sm' | 'lg';
interface IProgressBar {
    value: number;
    color?: ProgressBarColorsType;
    size?: ProgressBarSizesType;
    showValue?: boolean;
    isRtl?: boolean;
    containerClassName?: string;
    valueColor?: ITypography['color'];
}
interface IProgressBarProgress {
    scheme?: ProgressBarColorsType;
    size?: ProgressBarSizesType;
    isRtl?: boolean;
}

declare const ProgressBarComponent: FC<IProgressBar>;

type ProgressCircleSizesType = 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
type ProgressCircleColorsType = ColorsNameType;
interface IProgressCircle {
    value: number;
    size?: ProgressCircleSizesType;
    label?: string;
    color?: ProgressCircleColorsType;
    percentNumberVisibility?: boolean;
}

declare const ProgressCircleComponent: FC<IProgressCircle>;

type SwitchSizesType = 'sm' | 'md';
type SwitchColorsType = ColorsNameType;
interface ISwitch extends SwitchProps {
    checked?: boolean;
    disabled?: boolean;
    size?: SwitchSizesType;
    color?: SwitchColorsType;
    title?: string;
    hint?: string;
}
interface ICustomSwitch {
    scheme?: SwitchColorsType;
}

/**
 *
 * @author Ali M. Sadeghi
 * @version 0.0.1
 */
declare const SwitchComponent: FC<ISwitch>;

type TagSizesType = 'sm' | 'md' | 'lg';
interface ITag {
    children?: ReactNode;
    round?: `${number}px`;
    size?: TagSizesType;
}
interface ITagTitle extends ITypography {
    title?: string;
}
interface ITagClose extends SVGProps<SVGSVGElement> {
}
interface ITagCount extends ITypography {
}
interface ITagAvatar extends IAvatar {
}

/**
 *
 * @author Ali M. Sadeghi
 *
 */
declare const TagComponent: React__default.FC<ITag> & {
    Title: React__default.FC<ITagTitle>;
    Close: React__default.FC<ITagClose>;
    Count: React__default.FC<ITagCount>;
    Avatar: React__default.FC<ITagAvatar>;
};

type TextareaColorsType = ColorsNameType;
interface ITextarea extends TextareaHTMLAttributes<HTMLTextAreaElement> {
    label?: string;
    id?: string;
    helperText?: string;
    containerClassName?: string;
    color?: TextareaColorsType;
    disabled?: boolean;
    error?: boolean;
    mandatory?: boolean;
}
interface ITextareaHelperText {
    error?: boolean;
}

/**
 * @version 0.0.2
 * @author Ali M. Sadeghi
 * @lastUpdate change the color of placeholder, made it lighter.
 */
declare const TextareaComponent: React__default.ForwardRefExoticComponent<ITextarea & React__default.RefAttributes<HTMLTextAreaElement>>;

type ToastVariantsType = 'danger' | 'info' | 'success';
interface IToast {
    isOpen: boolean;
    onClose: () => void;
    variant?: ToastVariantsType;
    children?: ReactNode;
    hasIcon?: boolean;
}
interface IToastTitle extends ITypography {
}
interface IToastDescription extends ITypography {
}
interface IToastButtonGroup extends React.HTMLAttributes<HTMLDivElement> {
}
interface IToastButton extends IButton {
}
interface IToastColorMapper {
    success: 'success';
    info: 'primary';
    danger: 'error';
}
interface IToastIconNameMapper {
    success: 'check';
    info: 'info';
    danger: 'danger';
}

declare const Toast: FC<IToast>;
declare const ToastComponent: React__default.FC<IToast> & {
    Title: React__default.FC<IToastTitle>;
    Description: React__default.FC<IToastDescription>;
    ButtonGroup: React__default.FC<IToastButtonGroup>;
    PrimaryButton: React__default.FC<IToastButton>;
    SecondaryButton: React__default.FC<IToastButton>;
};

type WavyIconColors = ColorsNameType;
type WavyIconNames = 'check' | 'info' | 'danger';
interface IWavyIcon {
    color?: WavyIconColors;
    name: WavyIconNames;
}
interface IWavyIconWave {
    color?: WavyIconColors;
    opacity?: number;
    padding?: number;
}
interface IWavyIconSymbol {
    color?: WavyIconColors;
}

declare const WavyIconComponent: FC<IWavyIcon>;

interface IPagination {
    countButtonProps?: IButton;
    options?: UsePaginationProps;
    nextButtonProps?: IPaginationSideButton;
    previousButtonProps?: IPaginationSideButton;
    countClassName?: string;
}
interface IPaginationSideButton extends Omit<IButton, 'children'> {
    text?: string;
}
interface IPaginationButton extends Omit<IButton, 'type'> {
    type: UsePaginationItem['type'];
    page?: UsePaginationItem['page'];
    isSelected?: boolean;
    nextButtonProps?: IPaginationSideButton;
    countButtonProps?: IButton;
    previousButtonProps?: IPaginationSideButton;
}

declare const PaginationComponent: FC<IPagination>;

interface ITooltip extends TooltipProps {
    contentClassName?: string;
    backgroundColor?: string;
    shadow?: boolean;
    description?: string | React.ReactNode;
    placement?: 'bottom-end' | 'bottom-start' | 'bottom' | 'left-end' | 'left-start' | 'left' | 'right-end' | 'right-start' | 'right' | 'top-end' | 'top-start' | 'top';
}

declare const TooltipComponent: FC<ITooltip>;

declare const VerticalStepComponent: FC<IVerticalStep>;

declare const VerticalStepStyle: {
    Container: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme> & IVerticalStep, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
    Content: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
    StatusBox: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
    Status: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
    Line: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
    Icon: _emotion_styled.StyledComponent<React$1.SVGProps<SVGSVGElement> & _mui_system.MUIStyledCommonProps<_mui_material.Theme>, {}, {}>;
    Title: _emotion_styled.StyledComponent<ITypography & _mui_system.MUIStyledCommonProps<_mui_material.Theme>, {}, {}>;
    Subtitle: _emotion_styled.StyledComponent<ITypography & _mui_system.MUIStyledCommonProps<_mui_material.Theme>, {}, {}>;
    Header: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
};

type VerticalStepSizes = 'sm' | 'md' | 'lg';
type VerticalStepColors = ColorsNameType;
interface IVerticalStep {
    disable?: boolean;
    title?: string;
    subtitle?: string;
    size?: VerticalStepSizes;
    color?: VerticalStepColors;
    active?: boolean;
    focus?: boolean;
    children?: ReactNode;
    onSelect?: () => void;
    noLine?: boolean;
}

interface IStyledModal {
    isRtl?: boolean;
}
interface ICloseIconWrapper {
    isRtl?: boolean;
}
interface IModalProps {
    children: React.ReactNode;
    open: boolean;
    isRtl?: boolean;
    onClose: () => void;
}

/**
 *
 * @author AudreyBozorgi
 * @version 0.0.2
 * @description A React component that renders a moda.
 * @madeUse Emotion
 */
declare const ModalComponent: FC<IModalProps>;

interface IBasicModalProps {
    children: React.ReactNode;
    open: boolean;
    className?: string;
    onClose: () => void;
}

interface IModalHeaderProps {
    children?: React.ReactNode;
    style?: React.CSSProperties;
    className?: string;
    iconColor?: string;
    iconSize?: string;
}

interface IModalBodyProps {
    children?: React.ReactNode;
    style?: React.CSSProperties;
    className?: string;
}

interface IModalFooterProps {
    children?: React.ReactNode;
    style?: React.CSSProperties;
    className?: string;
}

/**
 * @author Audelqua
 * @version 0.0.2
 * @description A React component that renders a basic modal.
 * @madeUse Emotion
 */
declare const BasicModalComponent: FC<IBasicModalProps> & {
    Header: React__default.FC<IModalHeaderProps>;
    Body: React__default.FC<IModalBodyProps>;
    Footer: React__default.FC<IModalFooterProps>;
};

type DotLineVariantsType = 'normal' | 'active' | 'inactive';
type DotLineSizesType = 'sm' | 'md' | 'lg' | 'xs';
interface IDotLineContainer {
    variant?: DotLineVariantsType;
    size?: DotLineSizesType;
    dotSize?: IDot['size'];
}
interface IDotLine extends IDotLineContainer {
    title: string;
    subtitle?: React.ReactNode;
    className?: string;
    dotProps?: Omit<IDot, 'size' | 'children'>;
    customColor?: DotColorsType;
    customDotVariant?: IDot['variant'];
    customLineVariant?: DotLineVariantsType;
}

declare const DotLineComponent: FC<IDotLine>;

declare const dotVariantMapper: Record<DotLineVariantsType, IDot['variant']>;
declare const dotColorMapper: Record<DotLineVariantsType, IDot['color']>;

type IButtonGroupVariant = Exclude<IButton['variant'], 'link'>;
interface IContainer {
    disabled?: boolean;
}
interface IExtendedButton extends IButton {
    borderColor?: IButton['color'];
}
interface IButtonGroup extends Omit<IExtendedButton, 'children' | 'isLoading' | 'loadingContent' | 'onClick'> {
    variant?: IButtonGroupVariant;
    children: Array<React.ReactElement<IButtonGroupItem>>;
}
interface IButtonGroupItem extends Pick<IExtendedButton, 'color' | 'borderColor' | 'variant' | 'disabled' | 'children' | 'onClick' | 'className'> {
    variant?: IButtonGroupVariant;
}
type IButtonGroupCompound = React.FC<IButtonGroup> & {
    Button: React.FC<IButtonGroupItem>;
};

declare const ButtonGroupComponent: IButtonGroupCompound;

interface IRadioButtonGroup extends Omit<IButtonGroup, 'value' | 'onChange'> {
    id?: string;
    label?: string;
    hint?: string;
    error?: boolean;
    mandatory?: boolean;
}
interface IRadioButtonGroupItem extends IButtonGroupItem, Omit<InputHTMLAttributes<HTMLInputElement>, 'color' | 'onClick'> {
}
type IRadioButtonGroupCompound = React.FC<IRadioButtonGroup> & {
    Option: React.FC<IButtonGroupItem>;
};
interface IRadioButtonGroupDescription {
    error?: boolean;
}

declare const RadioButtonGroupComponent: IRadioButtonGroupCompound;

interface IGaugeChart extends GaugeProps {
    className?: string;
    color?: ColorsNameType;
    isRTL?: boolean;
}

/**
 * @author Shayan Montazeri
 * @version 0.0.1
 * @description A customizable circle Gauge chart component
 */
declare const GaugeChartComponent: FC<IGaugeChart>;

interface ITreeSelectInput {
    text: string;
    placeholder?: string;
    showCleanButton?: boolean;
    onClean?: React.MouseEventHandler<HTMLDivElement>;
    onClick?: React.MouseEventHandler<HTMLDivElement>;
    clearBadgeText?: string;
}

declare const TreeSelectInputComponent: React__default.FC<ITreeSelectInput>;

declare const VerticalStepperComponent: FC<IVerticalStepper>;

declare const VerticalStepperStyle: {
    Container: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
};

interface IVerticalStepper {
    children?: ReactNode;
}

interface IDateCalendar extends DateCalendarProps<{}> {
    lang?: 'fa' | 'en';
}

declare const DateCalendarComponent: FC<IDateCalendar>;

declare const DateCalendarStyle: {
    Container: _emotion_styled.StyledComponent<_mui_system.MUIStyledCommonProps<_mui_material.Theme>, React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
};

type TimelineGetVariantType = (index: number) => IDotLine['variant'];
interface ITimelineStepItem<T = string> {
    name: T;
    startDate?: string;
    deadline?: string;
}
interface ITimelineStep<T = string> {
    steps: ITimelineStepItem<T>[];
    status: T;
    hasSubtitle?: boolean;
    startDateTitle?: string;
    endDateTitle?: string;
}

declare const TimelineStepComponent: <T extends string>({ steps, status, hasSubtitle, startDateTitle, endDateTitle, }: ITimelineStep<T>) => React__default.ReactNode;

interface IRulerProgressProps {
    header: IRulerProgressHeader;
    setting?: IRulerProgressSetting;
    amount: string | number;
    wrapperBox?: boolean;
    containerClassName?: string;
    isRtl?: boolean;
    tooltipClassName?: string;
}
interface IRulerProgressTooltip extends Omit<ITooltip, 'children'> {
    children?: ITooltip['children'];
}
interface IRulerProgressHeader {
    title: string;
    className?: string;
    tooltip?: IRulerProgressTooltip;
    containerClassName?: string;
    iconClassName?: string;
    rightSection?: {
        title: string;
        value: string;
        className?: string;
    };
}
interface IRulerProgressSetting {
    color?: ColorsNameType;
    colorAmount: ColorAmountType;
    indicatorConfig?: IIndicatorConfig[];
}
interface IIndicatorConfig {
    text: string | undefined;
}
interface IProgressIndicatorProps {
    color?: ColorsNameType;
    colorAmount?: ColorAmountType;
}

declare const RulerProgressBar: React__default.FC<IRulerProgressProps>;

interface IAvatarTooltipGroupData {
    id?: string;
    name?: string;
    description?: string;
}
interface IAvatarTooltipGroup extends Omit<IAvatarGroup, 'wrapper'> {
    data: IAvatarTooltipGroupData[];
}

declare const AvatarTooltipGroupComponent: FC<IAvatarTooltipGroup>;

interface ICascadeOption {
    value?: string;
    label?: React.ReactNode;
    title?: React.ReactNode;
    disabled?: boolean;
    disableCheckbox?: boolean;
    isLeaf?: boolean;
    loading?: boolean;
    children?: Array<ICascadeOption>;
}
interface ICascadeProps extends Omit<ComponentProps<typeof Cascader>, 'value' | 'onChange'> {
    value: Array<Array<string>>;
    options: Array<ICascadeOption>;
    placeholder?: string;
    placeholderInputText: string;
    onChange: CascaderProps<any, 'value', true>['onChange'];
    loadData: CascaderProps<any, 'value'>['loadData'];
    onDropdownVisibleChange?: CascaderProps<any, 'value'>['onOpenChange'];
    clearText?: string;
}

declare const CascadeComponent: React__default.FC<ICascadeProps>;

interface ICascadeSelectSingleOptionBasic {
    value?: string;
    label?: React.ReactNode;
    title?: React.ReactNode;
    disabled?: boolean;
    disableCheckbox?: boolean;
    isLeaf?: boolean;
    loading?: boolean;
    children?: Array<ICascadeSelectSingleOptionBasic>;
}
interface ICascadeCascadeSelectSingle extends Omit<ComponentProps<typeof Cascader>, 'value' | 'onChange'> {
    value?: Array<Array<string>> | any;
    options: Array<ICascadeSelectSingleOptionBasic>;
    children?: CascaderProps<any, 'value'>['children'];
    onChange?: CascaderProps<any, 'value'>['onChange'];
    loadData: CascaderProps<any, 'value'>['loadData'];
    onDropdownVisibleChange?: CascaderProps<any, 'value'>['onDropdownVisibleChange'];
    checkable?: CascaderProps<any, 'value'>['checkable'];
}
interface ICascadeSelectSingleOption extends Pick<ICascadeSelectSingleOptionBasic, 'label' | 'value'> {
}
interface ICascadeSelectSingleProps extends Omit<ICascadeCascadeSelectSingle, 'value' | 'onChange'>, Omit<IFormContainer, 'children'> {
    value?: ICascadeSelectSingleOption;
    onChange?(value: ICascadeSelectSingleOption): void;
    placeholder: string;
    className?: CascaderProps['className'];
}

declare const CascadeSelectSingleComponent: React__default.FC<ICascadeSelectSingleProps>;

interface IThemeProviderProps {
    children: ReactNode;
    theme?: Theme;
}

declare const ThemeProviderComponent: FC<IThemeProviderProps>;

interface IAppProviderProps extends Partial<Pick<IThemeProviderProps, 'theme'>> {
    children: ReactNode;
}

declare const AppProviderComponent: ({ children, theme }: IAppProviderProps) => React__default.JSX.Element;

declare const ToastProviderComponent: FC;

interface IUseToast {
    id?: string;
    children?: ReactNode;
}
interface INotify {
    variant?: ToastVariantsType;
    title?: string;
    description?: string;
    id?: string;
    children?: ReactNode;
}

declare const useToast: ({}: IUseToast) => ({ title, description, variant, children, id }: INotify) => string;

export { Alert, AlertComponent, type AlertVariantsType, AppProviderComponent, AvatarComponent, AvatarGroupComponent, AvatarLabelGroupComponent, type AvatarLabelGroupSizesType, AvatarProfileComponent, type AvatarSizesType, type AvatarStatusesType, AvatarTooltipGroupComponent, type BadgeColorsType, BadgeComponent, type BadgeRoundsType, type BadgeSizesType, type BadgeVariantsType, BasicModalComponent, type ButtonColorsType, ButtonComponent, ButtonGroupComponent, type ButtonSizesType, type ButtonVariantsType, CascadeComponent, CascadeSelectSingleComponent, type CheckboxColorsType, CheckboxComponent, type CheckboxSizesType, CircularProgressComponent, type ColorAmountType, type ColorsNameType, DateCalendarComponent, DateCalendarStyle, type DotColorsType, DotComponent, DotLineComponent, type DotLineSizesType, type DotLineVariantsType, type DotSizesType, type DotVariantsType, DropdownComponent, type EnterCodeColorsType, EnterCodeComponent, type EnterCodeSizesType, FormContainerComponent, GaugeChartComponent, type IAlert, type IAlertButton, type IAlertButtonGroup, type IAlertContent, type IAlertSurface, type IAlertText, type IAlertVariantMapper, type IAvatar, type IAvatarGroup, type IAvatarGroupSizesType, type IAvatarLabelGroup, type IAvatarLabelGroupContent, type IAvatarProfile, type IAvatarProfileSizesType, type IAvatarTooltipGroup, type IAvatarTooltipGroupData, type IBadge, type IBadgeIcon, type IBasicModalProps, type IButton, type IButtonGroup, type IButtonGroupCompound, type IButtonGroupItem, type ICascadeCascadeSelectSingle, type ICascadeOption, type ICascadeProps, type ICascadeSelectSingleOption, type ICascadeSelectSingleOptionBasic, type ICascadeSelectSingleProps, type ICheckbox, type ICheckboxFrame, type ICheckboxSizeMapper, type ICircularProgress, type ICloseIconWrapper, type IColorAmount, type IColorsName, type IContainer, type ICustomSwitch, type IDateCalendar, type IDot, type IDotLine, type IDotLineContainer, type IDropdown, type IDropdownColorType, type IDropdownComponent, type IEnterCode, type IEnterCodeDescription, type IEnterCodeWrapper, type IExtendedButton, type IFonts, type IFormContainer, type IFormContainerColorType, type IFormContainerContent, type IFormContainerDescription, type IFormContainerField, type IGaugeChart, type IIndicatorConfig, type IInput, type IInputColorType, type IInputContainer, type IInputDescription, type IInputField, type IModalProps, type IOverrideColors, type IPagination, type IPaginationButton, type IPaginationSideButton, type IProgressBar, type IProgressBarProgress, type IProgressCircle, type IProgressIndicatorProps, type IRadio, type IRadioButtonGroup, type IRadioButtonGroupCompound, type IRadioButtonGroupDescription, type IRadioButtonGroupItem, type IRadioFrame, type IRadioSizeMapper, type IRedStar, type IRulerProgressHeader, type IRulerProgressProps, type IRulerProgressSetting, type IRulerProgressTooltip, type ISignal, type ISkeleton, type IStyledModal, type ISwitch, type ITag, type ITagAvatar, type ITagClose, type ITagCount, type ITagTitle, type ITextarea, type ITextareaHelperText, type ITimelineStep, type ITimelineStepItem, type IToast, type IToastButton, type IToastButtonGroup, type IToastColorMapper, type IToastDescription, type IToastIconNameMapper, type IToastTitle, type ITooltip, type ITypography, type ITypographyTags, type IVerticalStep, type IVerticalStepper, type IWavyIcon, type IWavyIconSymbol, type IWavyIconWave, InputComponent, ModalComponent, PaginationComponent, PopoverComponent, type ProgressBarColorsType, ProgressBarComponent, type ProgressBarSizesType, type ProgressCircleColorsType, ProgressCircleComponent, type ProgressCircleSizesType, RadioButtonGroupComponent, type RadioColorsType, RadioComponent, type RadioSizesType, RedStarComponent, RulerProgressBar, SignalComponent, SkeletonComponent, type SwitchColorsType, SwitchComponent, type SwitchSizesType, TagComponent, type TagSizesType, type TextareaColorsType, TextareaComponent, ThemeProviderComponent, type TimelineGetVariantType, TimelineStepComponent, Toast, ToastComponent, ToastProviderComponent, type ToastVariantsType, TooltipComponent, TreeSelectInputComponent, TypographyComponent, type TypographySizesType, type TypographyWeights, type VerticalStepColors, VerticalStepComponent, type VerticalStepSizes, VerticalStepStyle, VerticalStepperComponent, VerticalStepperStyle, type WavyIconColors, WavyIconComponent, type WavyIconNames, dotColorMapper, dotVariantMapper, useEnterCode, useToast };