react-asc 25.5.6 → 25.7.0

package/index.d.ts

@@ -1,139 +1,141 @@
 /// <reference types="react" />
 import React$1, { ReactNode, Component, ComponentProps, ReactElement } from 'react';
 
-declare enum COLOR {
-    primary = "primary",
-    accent = "accent",
-    secondary = "secondary",
-    danger = "danger",
-    light = "light",
-    dark = "dark"
-}
-declare enum VARIANT {
-    contained = "contained",
-    outline = "outline",
-    text = "text"
-}
-declare enum SIZE {
-    sm = "sm",
-    md = "md",
-    lg = "lg"
-}
-declare enum POSITION {
-    right = "right",
-    left = "left"
-}
-declare enum STATUS {
-    HOVERED = "hovered",
-    NORMAL = "normal"
-}
-
-interface IAlertProps extends React$1.ComponentProps<'div'> {
-    children?: ReactNode;
-    className?: string;
-    variant?: VARIANT;
-    color?: COLOR;
-    shadow?: boolean | SIZE.sm | SIZE.md | SIZE.lg;
-}
+declare enum COLOR {
+    primary = "primary",
+    accent = "accent",
+    secondary = "secondary",
+    danger = "danger",
+    light = "light",
+    dark = "dark"
+}
+declare enum VARIANT {
+    contained = "contained",
+    outline = "outline",
+    text = "text"
+}
+declare enum SIZE {
+    sm = "sm",
+    md = "md",
+    lg = "lg"
+}
+declare enum POSITION {
+    right = "right",
+    left = "left"
+}
+declare enum STATUS {
+    HOVERED = "hovered",
+    NORMAL = "normal"
+}
+
+interface IAlertProps extends React$1.ComponentProps<'div'> {
+    children?: ReactNode;
+    className?: string;
+    variant?: VARIANT;
+    color?: COLOR;
+    shadow?: boolean | SIZE.sm | SIZE.md | SIZE.lg;
+}
 declare const Alert: (props: IAlertProps) => JSX.Element;
 
-interface IAppBarProps extends React$1.ComponentProps<'nav'> {
-    children?: ReactNode;
-    className?: string;
-    color?: COLOR;
-    shadow?: boolean | SIZE.sm | SIZE.md | SIZE.lg;
-}
+interface IAppBarProps extends React$1.ComponentProps<'nav'> {
+    children?: ReactNode;
+    className?: string;
+    color?: COLOR;
+    shadow?: boolean | SIZE.sm | SIZE.md | SIZE.lg;
+}
 declare const AppBar: (props: IAppBarProps) => JSX.Element;
 
-interface IAppBarTitleProps extends React$1.ComponentProps<'div'> {
-    children?: ReactNode;
-}
+interface IAppBarTitleProps extends React$1.ComponentProps<'div'> {
+    children?: ReactNode;
+}
 declare const AppBarTitle: (props: IAppBarTitleProps) => JSX.Element;
 
-interface HtmlBaseProps {
-    className?: string;
-    id?: string;
-    name?: string;
-    autoFocus?: boolean;
-    readOnly?: boolean;
-    disabled?: boolean;
-}
-interface HtmlInputProps extends HtmlBaseProps {
-    onBlur?: (val: React.FocusEvent<HTMLInputElement>) => void;
-    onChange?: (val: React.FocusEvent<HTMLInputElement>) => void;
-    placeholder?: string;
-}
-interface ISelectOption {
-    value: string;
-    label?: React.ReactNode;
-}
-
-interface IAutoCompleteProps {
-    id?: string;
-    name?: string;
-    className?: string;
-    options?: ISelectOption[];
-    value?: string;
-    openOnFocus?: boolean;
-    disabled?: boolean;
-    placeholder?: string;
-    readOnly?: boolean;
-    debounce?: number;
-    showClearButton?: boolean;
-    onSelect?: (val: ISelectOption) => void;
-    onChange?: (val: string | undefined) => void;
-}
+interface HtmlBaseProps {
+    className?: string;
+    id?: string;
+    name?: string;
+    autoFocus?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+}
+interface HtmlInputProps extends HtmlBaseProps {
+    onBlur?: (val: React.FocusEvent<HTMLInputElement>) => void;
+    onChange?: (val: React.FocusEvent<HTMLInputElement>) => void;
+    placeholder?: string;
+}
+interface ISelectOption {
+    value: string;
+    label?: React.ReactNode;
+}
+
+interface IAutoCompleteProps {
+    id?: string;
+    name?: string;
+    className?: string;
+    options?: ISelectOption[];
+    value?: string;
+    openOnFocus?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    debounce?: number;
+    showClearButton?: boolean;
+    onSelect?: (val: ISelectOption) => void;
+    onChange?: (val: string | undefined) => void;
+}
 declare const AutoComplete: (props: IAutoCompleteProps) => JSX.Element;
 
-interface IBackdropProps extends React$1.ComponentProps<'div'> {
-    target?: HTMLElement;
-    isTransparent?: boolean;
-}
+interface IBackdropProps extends React$1.ComponentProps<'div'> {
+    target?: HTMLElement;
+    isTransparent?: boolean;
+}
 declare const Backdrop: (props: IBackdropProps) => JSX.Element;
 
-interface IBadgeProps extends React$1.ComponentProps<'div'> {
-    color?: COLOR;
-    content?: React$1.ReactNode;
-}
+interface IBadgeProps {
+    color?: COLOR;
+    content?: React$1.ReactNode;
+    className?: string;
+    children?: React$1.ReactNode;
+}
 declare const Badge: (props: IBadgeProps) => JSX.Element;
 
-interface IBreadcrumbProps extends React$1.ComponentProps<'nav'> {
-    children?: ReactNode;
-}
+interface IBreadcrumbProps extends React$1.ComponentProps<'nav'> {
+    children?: ReactNode;
+}
 declare const Breadcrumb: (props: IBreadcrumbProps) => JSX.Element;
 
-interface IBreadcrumbItemProps extends React$1.ComponentProps<'li'> {
-    isActive?: boolean;
-    path?: string;
-}
+interface IBreadcrumbItemProps extends React$1.ComponentProps<'li'> {
+    isActive?: boolean;
+    path?: string;
+}
 declare const BreadcrumbItem: (props: IBreadcrumbItemProps) => JSX.Element;
 
-interface IButtonProps extends React$1.ComponentProps<'button'> {
-    color?: COLOR;
-    isActive?: boolean;
-    isRounded?: boolean;
-    variant?: VARIANT;
-    startIcon?: React$1.ReactNode;
-    endIcon?: React$1.ReactNode;
-    shadow?: boolean;
-    block?: boolean;
-}
+interface IButtonProps extends React$1.ComponentProps<'button'> {
+    color?: COLOR;
+    isActive?: boolean;
+    isRounded?: boolean;
+    variant?: VARIANT;
+    startIcon?: React$1.ReactNode;
+    endIcon?: React$1.ReactNode;
+    shadow?: boolean;
+    block?: boolean;
+}
 declare const Button: React$1.FunctionComponent<IButtonProps>;
 
-interface IButtonContext {
-    color: COLOR | null;
-}
-declare const ButtonContext: React.Context<IButtonContext>;
+interface IButtonContext {
+    color: COLOR | null;
+}
+declare const ButtonContext: React.Context<IButtonContext>;
 declare const useButtonContext: () => IButtonContext;
 
-interface IButtonGroupProps extends React$1.ComponentProps<'div'> {
-    color?: COLOR;
-}
+interface IButtonGroupProps extends React$1.ComponentProps<'div'> {
+    color?: COLOR;
+}
 declare const ButtonGroup: (props: IButtonGroupProps) => JSX.Element;
 
-interface ICardProps extends React$1.ComponentProps<'div'> {
-    shadow?: boolean;
-}
+interface ICardProps extends React$1.ComponentProps<'div'> {
+    shadow?: boolean;
+}
 declare const Card: (props: ICardProps) => JSX.Element;
 
 declare const CardBody: (props: React$1.ComponentProps<'div'>) => JSX.Element;
@@ -144,281 +146,281 @@ declare const CardSubtitle: (props: React$1.ComponentProps<'div'>) => JSX.Elemen
 
 declare const CardText: (props: React$1.ComponentProps<'p'>) => JSX.Element;
 
-interface ICardTitleProps extends React$1.ComponentProps<'div'> {
-    as?: any;
-}
+interface ICardTitleProps extends React$1.ComponentProps<'div'> {
+    as?: any;
+}
 declare const CardTitle: (props: ICardTitleProps) => JSX.Element;
 
 declare const CardImage: (props: React$1.ComponentProps<'img'>) => JSX.Element;
 
-interface ICheckboxProps extends React$1.ComponentProps<'input'> {
-    label?: string;
-    value?: string;
-    onKeyDown?: (event: React$1.KeyboardEvent) => void;
-}
+interface ICheckboxProps extends React$1.ComponentProps<'input'> {
+    label?: string;
+    value?: string;
+    onKeyDown?: (event: React$1.KeyboardEvent) => void;
+}
 declare const Checkbox: (props: ICheckboxProps) => JSX.Element;
 
-interface IChipProps extends React$1.ComponentProps<'div'> {
-    color?: COLOR;
-    shadow?: boolean;
-    onClick?: (e: React$1.MouseEvent<Element>) => void;
-    isDeletable?: boolean;
-    onDelete?: (e: React$1.MouseEvent<Element>) => void;
-    deleteIcon?: JSX.Element;
-}
+interface IChipProps extends React$1.ComponentProps<'div'> {
+    color?: COLOR;
+    shadow?: boolean;
+    onClick?: (e: React$1.MouseEvent<Element>) => void;
+    isDeletable?: boolean;
+    onDelete?: (e: React$1.MouseEvent<Element>) => void;
+    deleteIcon?: JSX.Element;
+}
 declare const Chip: (props: IChipProps) => JSX.Element;
 
-interface IConditionalWrapperProps {
-    condition: boolean;
-    wrapper: (children: React$1.ReactNode) => JSX.Element;
-    children: any;
-}
+interface IConditionalWrapperProps {
+    condition: boolean;
+    wrapper: (children: React$1.ReactNode) => JSX.Element;
+    children: any;
+}
 declare const ConditionalWrapper: ({ condition, wrapper, children }: IConditionalWrapperProps) => JSX.Element;
 
-interface ICssTransitionProps {
-    className: string;
-    children: React$1.ReactNode;
-    show: boolean;
-}
+interface ICssTransitionProps {
+    className: string;
+    children: React$1.ReactNode;
+    show: boolean;
+}
 declare const CssTransition: (props: ICssTransitionProps) => JSX.Element;
 
-interface IDatePickerProps {
-    value?: Date;
-    selectRange?: boolean;
-    minDate?: Date;
-    maxDate?: Date;
-    onChange?: (val: Date) => void;
-}
+interface IDatePickerProps {
+    value?: Date;
+    selectRange?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    onChange?: (val: Date) => void;
+}
 declare const DatePicker: (props: IDatePickerProps) => JSX.Element;
 
-declare enum DATEMODE {
-    YEAR = 0,
-    MONTH = 1,
-    DAY = 2
-}
-interface IDateSelectProps {
-    value?: Date;
-    className?: string;
-    disabled?: boolean;
-    yearConfig?: {
-        from?: number;
-        to?: number;
-    };
-    onChange?: (val: Date) => void;
-}
+declare enum DATEMODE {
+    YEAR = 0,
+    MONTH = 1,
+    DAY = 2
+}
+interface IDateSelectProps {
+    value?: Date;
+    className?: string;
+    disabled?: boolean;
+    yearConfig?: {
+        from?: number;
+        to?: number;
+    };
+    onChange?: (val: Date) => void;
+}
 declare const DateSelect: (props: IDateSelectProps) => JSX.Element;
 
-interface IYearProps {
-    from?: number;
-    to?: number;
-    value?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface IYearProps {
+    from?: number;
+    to?: number;
+    value?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const YearSelect: (props: IYearProps) => JSX.Element;
 
-interface IDaySelectProps {
-    day?: number;
-    month?: number;
-    year?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface IDaySelectProps {
+    day?: number;
+    month?: number;
+    year?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const DaySelect: (props: IDaySelectProps) => JSX.Element;
 
-interface IMonthProps {
-    value?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface IMonthProps {
+    value?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const MonthSelect: (props: IMonthProps) => JSX.Element;
 
-interface IDrawerProps extends React$1.ComponentProps<'div'> {
-    position?: 'left' | 'right';
-    shadow?: boolean;
-    onClickBackdrop?: () => void;
-    permanent?: boolean;
-    target?: HTMLElement;
-}
+interface IDrawerProps extends React$1.ComponentProps<'div'> {
+    position?: 'left' | 'right';
+    shadow?: boolean;
+    onClickBackdrop?: () => void;
+    permanent?: boolean;
+    target?: HTMLElement;
+}
 declare const Drawer: (props: IDrawerProps) => JSX.Element;
 
-interface IExpansionPanelProps {
-    header: ReactNode;
-    children: ReactNode;
-    isExpanded?: boolean;
-    shadow?: boolean;
-    onChange?: (event: React$1.MouseEvent, isExpanded: boolean) => void;
-}
+interface IExpansionPanelProps {
+    header: ReactNode;
+    children: ReactNode;
+    isExpanded?: boolean;
+    shadow?: boolean;
+    onChange?: (event: React$1.MouseEvent, isExpanded: boolean) => void;
+}
 declare const ExpansionPanel: (props: IExpansionPanelProps) => JSX.Element;
 
-interface IExpansionPanelHeaderProps {
-    onClick?: (event: React$1.MouseEvent) => void;
-    children?: ReactNode;
-    isExpanded: boolean;
-}
+interface IExpansionPanelHeaderProps {
+    onClick?: (event: React$1.MouseEvent) => void;
+    children?: ReactNode;
+    isExpanded: boolean;
+}
 declare const ExpansionPanelHeader: (props: IExpansionPanelHeaderProps) => JSX.Element;
 
-interface IExpansionPanelContentProps {
-    children?: ReactNode;
-}
+interface IExpansionPanelContentProps {
+    children?: ReactNode;
+}
 declare const ExpansionPanelContent: ({ children }: IExpansionPanelContentProps) => JSX.Element;
 
-interface IFileInputProps extends React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
-    deletable?: boolean;
-}
+interface IFileInputProps extends React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> {
+    deletable?: boolean;
+}
 declare const FileInput: (props: IFileInputProps) => JSX.Element;
 
-interface IFloatingActionButtonProps extends React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
-    icon?: React$1.ReactNode;
-    color?: COLOR;
-    size?: SIZE;
-    fixed?: boolean;
-    isActive?: boolean;
-    disabled?: boolean;
-    position?: 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom';
-    onClick?: (e: React$1.MouseEvent) => void;
-}
+interface IFloatingActionButtonProps extends React$1.DetailedHTMLProps<React$1.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
+    icon?: React$1.ReactNode;
+    color?: COLOR;
+    size?: SIZE;
+    fixed?: boolean;
+    isActive?: boolean;
+    disabled?: boolean;
+    position?: 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom';
+    onClick?: (e: React$1.MouseEvent) => void;
+}
 declare const FloatingActionButton: (props: IFloatingActionButtonProps) => JSX.Element;
 
-declare type IFormControlType = 'text' | 'textarea' | 'email' | 'number' | 'checkbox' | 'checkboxgroup' | 'radio' | 'select' | 'password' | 'color' | 'time' | 'file' | 'date' | 'datetime-local' | 'autocomplete';
-declare type IFormValidatorType = 'required' | 'email' | 'match';
-
-declare class FormControl {
-    value: any;
-    validators: string[];
-    type: IFormControlType;
-    config: IFormControlConfig;
-    constructor(value: any, validators: string[], type: IFormControlType, config: IFormControlConfig);
-    errors: IFormInputError[];
-    isValid: boolean;
-    isDirty: boolean;
-}
-
-interface IControls {
-    [key: string]: FormControl;
-}
-interface IFormTextAreaOptions {
-    rows?: number;
-    resize?: boolean;
-}
-interface IFormSelectOptions {
-    multiple?: boolean;
-}
-interface IFormAutoCompleteOptions {
-    openOnFocus?: boolean;
-}
-interface IFormInputError {
-    validator: string;
-    message: string;
-}
-interface IFormInputOptions {
-    id?: string;
-    value: string;
-    label?: React.ReactNode;
-}
-interface IFormControlConfig {
-    label: string;
-    placeholder?: string;
-    formControlClassName?: string;
-    formGroupClassName?: string;
-    labelClassName?: string;
-    labelPosition?: string;
-    autoFocus?: boolean;
-    hint?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    options?: IFormInputOptions[];
-    textareaOptions?: IFormTextAreaOptions;
-    selectOptions?: IFormSelectOptions;
-    autoCompleteOptions?: IFormAutoCompleteOptions;
-}
-
-interface IFormProps {
-    className?: string;
-    controls: IControls;
-    validateOnBlur?: boolean;
-    onSubmit?: (values: any) => void;
-    onChange?: (values: any) => void;
-    submitOnEnter?: boolean;
-}
-interface IFormState {
-    controls: IControls | undefined;
-    isValid: boolean;
-    isSubmitted: boolean;
-    isChanged: boolean;
-    submitOnEnter?: boolean;
-}
-declare class Form extends Component<IFormProps, IFormState> {
-    constructor(props: IFormProps);
-    getCssClasses(): string;
-    static getDerivedStateFromProps(nextProps: IFormProps, state: IFormState): {
-        controls: IControls;
-    } | null;
-    myForm: React$1.RefObject<HTMLFormElement>;
-    handleChange(): void;
-    private validateField;
-    private handleInputChange;
-    private handleOnBlur;
-    private isRequired;
-    private isInvalid;
-    getControl(name: string): FormControl;
-    private renderLabel;
-    handleFormSubmit(): void;
-    handleFormReset(): void;
-    handleOnKeyDown(e: React$1.KeyboardEvent<HTMLInputElement | undefined>): void;
-    destroy(): void;
-    getFormGroupCssClass(fieldKey: string): string | undefined;
-    render(): JSX.Element;
-}
-
-interface IFormErrorProps {
-    className?: string;
-    errors?: IFormInputError[];
-}
+type IFormControlType = 'text' | 'textarea' | 'email' | 'number' | 'checkbox' | 'checkboxgroup' | 'radio' | 'select' | 'password' | 'color' | 'time' | 'file' | 'date' | 'datetime-local' | 'autocomplete';
+type IFormValidatorType = 'required' | 'email' | 'match';
+
+declare class FormControl {
+    value: any;
+    validators: string[];
+    type: IFormControlType;
+    config: IFormControlConfig;
+    constructor(value: any, validators: string[], type: IFormControlType, config: IFormControlConfig);
+    errors: IFormInputError[];
+    isValid: boolean;
+    isDirty: boolean;
+}
+
+interface IControls {
+    [key: string]: FormControl;
+}
+interface IFormTextAreaOptions {
+    rows?: number;
+    resize?: boolean;
+}
+interface IFormSelectOptions {
+    multiple?: boolean;
+}
+interface IFormAutoCompleteOptions {
+    openOnFocus?: boolean;
+}
+interface IFormInputError {
+    validator: string;
+    message: string;
+}
+interface IFormInputOptions {
+    id?: string;
+    value: string;
+    label?: React.ReactNode;
+}
+interface IFormControlConfig {
+    label: string;
+    placeholder?: string;
+    formControlClassName?: string;
+    formGroupClassName?: string;
+    labelClassName?: string;
+    labelPosition?: string;
+    autoFocus?: boolean;
+    hint?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    options?: IFormInputOptions[];
+    textareaOptions?: IFormTextAreaOptions;
+    selectOptions?: IFormSelectOptions;
+    autoCompleteOptions?: IFormAutoCompleteOptions;
+}
+
+interface IFormProps {
+    className?: string;
+    controls: IControls;
+    validateOnBlur?: boolean;
+    onSubmit?: (values: any) => void;
+    onChange?: (values: any) => void;
+    submitOnEnter?: boolean;
+}
+interface IFormState {
+    controls: IControls | undefined;
+    isValid: boolean;
+    isSubmitted: boolean;
+    isChanged: boolean;
+    submitOnEnter?: boolean;
+}
+declare class Form extends Component<IFormProps, IFormState> {
+    constructor(props: IFormProps);
+    getCssClasses(): string;
+    static getDerivedStateFromProps(nextProps: IFormProps, state: IFormState): {
+        controls: IControls;
+    } | null;
+    myForm: React$1.RefObject<HTMLFormElement>;
+    handleChange(): void;
+    private validateField;
+    private handleInputChange;
+    private handleOnBlur;
+    private isRequired;
+    private isInvalid;
+    getControl(name: string): FormControl;
+    private renderLabel;
+    handleFormSubmit(): void;
+    handleFormReset(): void;
+    handleOnKeyDown(e: React$1.KeyboardEvent<HTMLInputElement | undefined>): void;
+    destroy(): void;
+    getFormGroupCssClass(fieldKey: string): string | undefined;
+    render(): JSX.Element;
+}
+
+interface IFormErrorProps {
+    className?: string;
+    errors?: IFormInputError[];
+}
 declare const FormError: (props: IFormErrorProps) => JSX.Element;
 
-interface IFormGroupProps {
-    children?: React$1.ReactNode;
-    className?: string;
-}
+interface IFormGroupProps {
+    children?: React$1.ReactNode;
+    className?: string;
+}
 declare const FormGroup: (props: IFormGroupProps) => JSX.Element;
 
 declare const FormHint: (props: React$1.ComponentProps<'small'>) => JSX.Element;
 
-interface IFormInputEvent {
-    value: any;
-    type?: string;
-    name?: string;
-}
-interface IFormInputProps {
-    value: any;
-    name: string;
-    type: IFormControlType;
-    placeholder?: string;
-    className?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    isValid?: boolean;
-    autoFocus?: boolean;
-    options?: IFormInputOptions[];
-    textareaOptions?: IFormTextAreaOptions;
-    selectOptions?: IFormSelectOptions;
-    autoCompleteOptions?: IFormAutoCompleteOptions;
-    label?: string;
-    onInput?: (e: IFormInputEvent) => void;
-    onChange?: (e: IFormInputEvent) => void;
-    onBlur?: React$1.FocusEventHandler<HTMLInputElement> | undefined;
-    onKeyDown?: React$1.KeyboardEventHandler<HTMLInputElement | undefined>;
-}
+interface IFormInputEvent {
+    value: any;
+    type?: string;
+    name?: string;
+}
+interface IFormInputProps {
+    value: any;
+    name: string;
+    type: IFormControlType;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    isValid?: boolean;
+    autoFocus?: boolean;
+    options?: IFormInputOptions[];
+    textareaOptions?: IFormTextAreaOptions;
+    selectOptions?: IFormSelectOptions;
+    autoCompleteOptions?: IFormAutoCompleteOptions;
+    label?: string;
+    onInput?: (e: IFormInputEvent) => void;
+    onChange?: (e: IFormInputEvent) => void;
+    onBlur?: React$1.FocusEventHandler<HTMLInputElement> | undefined;
+    onKeyDown?: React$1.KeyboardEventHandler<HTMLInputElement | undefined>;
+}
 declare const FormInput: (props: IFormInputProps) => JSX.Element;
 
 declare const FormLabel: ({ children, className, htmlFor, ...rest }: React$1.ComponentProps<'label'>) => JSX.Element;
@@ -433,394 +435,394 @@ declare const MaxValidator: (val: string, valueB: number) => boolean;
 
 declare const MinValidator: (val: string, minLength: number) => boolean;
 
-interface IColProps extends React$1.ComponentProps<'div'> {
-    xs?: number;
-    sm?: number;
-    md?: number;
-    lg?: number;
-    xl?: number;
-}
+interface IColProps extends React$1.ComponentProps<'div'> {
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+}
 declare const Column: (props: IColProps) => JSX.Element;
 
-interface IContainerProps extends React$1.ComponentProps<'div'> {
-    direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
-}
+interface IContainerProps extends React$1.ComponentProps<'div'> {
+    direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
+}
 declare const Row: ({ children, direction, className, ...rest }: IContainerProps) => JSX.Element;
 
-interface IIconProps extends ComponentProps<'div'> {
-    iconColor?: COLOR;
-    children?: React$1.ReactNode;
-}
+interface IIconProps extends ComponentProps<'div'> {
+    iconColor?: COLOR;
+    children?: React$1.ReactNode;
+}
 declare const Icon: (props: IIconProps) => JSX.Element;
 
-interface IIconButtonProps extends React$1.ComponentProps<'button'> {
-    icon?: React$1.ReactNode;
-    color?: COLOR;
-    size?: SIZE;
-    isActive?: boolean;
-    variant?: VARIANT;
-    shadow?: boolean;
-}
+interface IIconButtonProps extends React$1.ComponentProps<'button'> {
+    icon?: React$1.ReactNode;
+    color?: COLOR;
+    size?: SIZE;
+    isActive?: boolean;
+    variant?: VARIANT;
+    shadow?: boolean;
+}
 declare const IconButton: (props: IIconButtonProps) => JSX.Element;
 
 declare const Link: (props: React$1.ComponentProps<'a'>) => JSX.Element;
 
-interface IListProps extends React$1.ComponentProps<'ul'> {
-    isFlush?: boolean;
-}
+interface IListProps extends React$1.ComponentProps<'ul'> {
+    isFlush?: boolean;
+}
 declare const List: (props: IListProps) => JSX.Element;
 
-interface IListItemProps extends React$1.ComponentProps<'li'> {
-    color?: COLOR;
-    active?: boolean;
-    isHoverable?: boolean;
-    disabled?: boolean;
-}
+interface IListItemProps extends React$1.ComponentProps<'li'> {
+    color?: COLOR;
+    active?: boolean;
+    isHoverable?: boolean;
+    disabled?: boolean;
+}
 declare const ListItem: (props: IListItemProps) => JSX.Element;
 
-interface IListItemAvatarProps extends React$1.ComponentProps<'div'> {
-    avatar: React$1.ReactNode;
-}
+interface IListItemAvatarProps extends React$1.ComponentProps<'div'> {
+    avatar: React$1.ReactNode;
+}
 declare const ListItemAvatar: ({ avatar, ...rest }: IListItemAvatarProps) => JSX.Element;
 
-interface IListItemIconProps extends React$1.ComponentProps<'div'> {
-    icon: React$1.ReactNode;
-}
+interface IListItemIconProps extends React$1.ComponentProps<'div'> {
+    icon: React$1.ReactNode;
+}
 declare const ListItemIcon: ({ icon, ...rest }: IListItemIconProps) => JSX.Element;
 
 declare const ListItemAction: ({ children, onClick, ...rest }: React$1.ComponentProps<'div'>) => JSX.Element;
 
-interface IListItemTextProps extends React$1.ComponentProps<'div'> {
-    primary: ReactNode;
-    secondary?: ReactNode;
-}
+interface IListItemTextProps extends React$1.ComponentProps<'div'> {
+    primary: ReactNode;
+    secondary?: ReactNode;
+}
 declare const ListItemText: ({ primary, secondary, ...rest }: IListItemTextProps) => JSX.Element;
 
 declare const LoadingIndicator: ({ ...rest }: React$1.ComponentProps<'div'>) => JSX.Element;
 
-interface ILoadingIndicatorContainerProps {
-    children: React$1.ReactNode;
-    isFixed?: boolean;
-}
+interface ILoadingIndicatorContainerProps {
+    children: React$1.ReactNode;
+    isFixed?: boolean;
+}
 declare const LoadingIndicatorContainer: ({ children, isFixed }: ILoadingIndicatorContainerProps) => JSX.Element;
 
-interface ILoadingIndicatorService {
-    show(message: string): void;
-}
-declare class LoadingIndicatorService implements ILoadingIndicatorService {
-    private container;
-    private handler;
-    private root;
-    show(): void;
-    hide(): void;
-}
+interface ILoadingIndicatorService {
+    show(message: string): void;
+}
+declare class LoadingIndicatorService implements ILoadingIndicatorService {
+    private container;
+    private handler;
+    private root;
+    show(): void;
+    hide(): void;
+}
 declare const loadingIndicatorService: LoadingIndicatorService;
 
-declare type MenuPosition = 'right' | 'left';
+type MenuPosition = 'right' | 'left';
 
-interface IMenuProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
-    toggle?: ReactElement;
-    open?: boolean;
-    children?: ReactElement<IListItemProps> | ReactElement<IListItemProps>[];
-    menuPosition?: MenuPosition;
-    onClickBackdrop?: () => void;
-}
+interface IMenuProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    toggle?: ReactElement;
+    open?: boolean;
+    children?: ReactElement<IListItemProps> | ReactElement<IListItemProps>[];
+    menuPosition?: MenuPosition;
+    onClickBackdrop?: () => void;
+}
 declare const Menu: (props: IMenuProps) => JSX.Element;
 
-interface IMenuBodyProps {
-    children?: ReactElement<IListItemProps> | ReactElement<IListItemProps>[];
-    className?: string;
-    menuPosition?: MenuPosition;
-    parentRef: React$1.RefObject<HTMLDivElement>;
-    shadow?: boolean;
-    onClickBackdrop?: () => void;
-}
+interface IMenuBodyProps {
+    children?: ReactElement<IListItemProps> | ReactElement<IListItemProps>[];
+    className?: string;
+    menuPosition?: MenuPosition;
+    parentRef: React$1.RefObject<HTMLDivElement>;
+    shadow?: boolean;
+    onClickBackdrop?: () => void;
+}
 declare const MenuBody: (props: IMenuBodyProps) => JSX.Element;
 
 declare const MenuItem: (props: IListItemProps) => JSX.Element;
 
-interface IMenuToggleProps {
-    children?: ReactNode;
-}
+interface IMenuToggleProps {
+    children?: ReactNode;
+}
 declare const MenuToggle: ({ children }: IMenuToggleProps) => ReactNode;
 
 declare const MenuDivider: () => JSX.Element;
 
-interface IModalProps$1 {
-    target?: HTMLElement;
-    className?: string;
-    children?: ReactNode;
-    header?: string | ReactElement;
-    footer?: string | ReactElement;
-    onHeaderCloseClick?: () => void;
-    onBackdropClick?: () => void;
-    isDismissable?: boolean;
-    fullScreen?: boolean;
-    size?: SIZE;
-}
+interface IModalProps$1 {
+    target?: HTMLElement;
+    className?: string;
+    children?: ReactNode;
+    header?: string | ReactElement;
+    footer?: string | ReactElement;
+    onHeaderCloseClick?: () => void;
+    onBackdropClick?: () => void;
+    isDismissable?: boolean;
+    fullScreen?: boolean;
+    size?: SIZE;
+}
 declare const Modal: (props: IModalProps$1) => JSX.Element;
 
-interface IModalBodyProps {
-    children?: ReactNode;
-}
+interface IModalBodyProps {
+    children?: ReactNode;
+}
 declare const ModalBody: ({ children }: IModalBodyProps) => JSX.Element;
 
-interface IModalFooterProps extends React$1.ComponentProps<'div'> {
-    shadow?: boolean;
-}
+interface IModalFooterProps extends React$1.ComponentProps<'div'> {
+    shadow?: boolean;
+}
 declare const ModalFooter: (props: IModalFooterProps) => JSX.Element;
 
-interface IModalHeaderProps extends React$1.ComponentProps<'div'> {
-    onClose?: () => void;
-    isDismissable?: boolean;
-    shadow?: boolean;
-}
+interface IModalHeaderProps extends React$1.ComponentProps<'div'> {
+    onClose?: () => void;
+    isDismissable?: boolean;
+    shadow?: boolean;
+}
 declare const ModalHeader: (props: IModalHeaderProps) => JSX.Element;
 
-declare enum MODALTYPE {
-    BASIC = "BASIC",
-    FORM = "FORM"
-}
-declare enum MODALBUTTONTYPE {
-    OK = "OK",
-    CANCEL = "CANCEL",
-    RESET = "RESET",
-    DEFAULT = "DEFAULT"
-}
-
-interface IModalButton {
-    label: string;
-    variant?: VARIANT;
-    color?: COLOR;
-    handler?: () => void;
-    autoFocus?: boolean;
-    type?: MODALBUTTONTYPE;
-    focus?: boolean;
-    shadow?: boolean;
-}
-
-interface IModalService {
-    show(title: string, description: string | ReactElement, options?: IModalOptions): Promise<void>;
-}
-interface IModalOptions {
-    isDismissable?: boolean;
-    buttons?: IModalButton[];
-    fullScreen?: boolean;
-    size?: SIZE;
-}
-declare class ModalService implements IModalService {
-    private container;
-    private root;
-    show(title: string, description: string | ReactElement, options?: IModalOptions): Promise<void>;
-    showForm<T>(title: string, formControls: IControls, options?: IModalOptions): Promise<T>;
-    private hide;
-}
+declare enum MODALTYPE {
+    BASIC = "BASIC",
+    FORM = "FORM"
+}
+declare enum MODALBUTTONTYPE {
+    OK = "OK",
+    CANCEL = "CANCEL",
+    RESET = "RESET",
+    DEFAULT = "DEFAULT"
+}
+
+interface IModalButton {
+    label: string;
+    variant?: VARIANT;
+    color?: COLOR;
+    handler?: () => void;
+    autoFocus?: boolean;
+    type?: MODALBUTTONTYPE;
+    focus?: boolean;
+    shadow?: boolean;
+}
+
+interface IModalService {
+    show(title: string, description: string | ReactElement, options?: IModalOptions): Promise<void>;
+}
+interface IModalOptions {
+    isDismissable?: boolean;
+    buttons?: IModalButton[];
+    fullScreen?: boolean;
+    size?: SIZE;
+}
+declare class ModalService implements IModalService {
+    private container;
+    private root;
+    show(title: string, description: string | ReactElement, options?: IModalOptions): Promise<void>;
+    showForm<T>(title: string, formControls: IControls, options?: IModalOptions): Promise<T>;
+    private hide;
+}
 declare const modalService: ModalService;
 
-interface IModalProps {
-    title?: string;
-    description?: string | ReactElement;
-    formControls?: IControls;
-    modalType?: MODALTYPE;
-    onOk: <T>(values?: T) => void;
-    onChange?: <T>(values?: T) => void;
-    onCancel?: () => void;
-    onBackdropClick?: () => void;
-    isDismissable?: boolean;
-    buttons?: IModalButton[];
-    fullScreen?: boolean;
-    size?: SIZE;
-}
+interface IModalProps {
+    title?: string;
+    description?: string | ReactElement;
+    formControls?: IControls;
+    modalType?: MODALTYPE;
+    onOk: <T>(values?: T) => void;
+    onChange?: <T>(values?: T) => void;
+    onCancel?: () => void;
+    onBackdropClick?: () => void;
+    isDismissable?: boolean;
+    buttons?: IModalButton[];
+    fullScreen?: boolean;
+    size?: SIZE;
+}
 declare const GlobalModal: ({ title, description, formControls, onOk, onChange, onCancel, onBackdropClick, isDismissable, buttons, size, fullScreen }: IModalProps) => JSX.Element;
 
-interface INumberSelectProps {
-    value?: number;
-    from?: number;
-    to?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface INumberSelectProps {
+    value?: number;
+    from?: number;
+    to?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const NumberSelect: (props: INumberSelectProps) => JSX.Element;
 
-interface IPortalProps {
-    children: React.ReactNode;
-    target?: HTMLElement;
-    className?: string;
-}
+interface IPortalProps {
+    children: React.ReactNode;
+    target?: HTMLElement;
+    className?: string;
+}
 declare const Portal: ({ children, target, className }: IPortalProps) => JSX.Element;
 
-interface IProgressBarProps extends React$1.ComponentProps<'div'> {
-    className?: string;
-    color?: COLOR;
-    value?: number;
-    indeterminate?: boolean;
-}
+interface IProgressBarProps extends React$1.ComponentProps<'div'> {
+    className?: string;
+    color?: COLOR;
+    value?: number;
+    indeterminate?: boolean;
+}
 declare const ProgressBar: (props: IProgressBarProps) => JSX.Element;
 
-interface ISelectProps {
-    id?: string;
-    name?: string;
-    className?: string;
-    options?: ISelectOption[];
-    value?: string | string[];
-    multiple?: boolean;
-    multipleMaxCountItems?: number;
-    disabled?: boolean;
-    readOnly?: boolean;
-    onChange?: (val: string | string[]) => void;
-    onKeyDown?: (event: React$1.KeyboardEvent<HTMLDivElement>) => void;
-}
+interface ISelectProps {
+    id?: string;
+    name?: string;
+    className?: string;
+    options?: ISelectOption[];
+    value?: string | string[];
+    multiple?: boolean;
+    multipleMaxCountItems?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    onChange?: (val: string | string[]) => void;
+    onKeyDown?: (event: React$1.KeyboardEvent<HTMLDivElement>) => void;
+}
 declare const Select: (props: ISelectProps) => JSX.Element;
 
-interface ISidebarItem {
-    id: string;
-    path: string;
-    label: string;
-    icon?: string;
-    items?: ISidebarItem[];
-    isCollapsible?: boolean;
-    isCollapsed?: boolean;
-}
-
-interface ISidebarProps extends React$1.ComponentProps<'nav'> {
-    items: ISidebarItem[];
-    currentUrl: string;
-    onItemClicked: (path: string) => void;
-}
+interface ISidebarItem {
+    id: string;
+    path: string;
+    label: string;
+    icon?: string;
+    items?: ISidebarItem[];
+    isCollapsible?: boolean;
+    isCollapsed?: boolean;
+}
+
+interface ISidebarProps extends React$1.ComponentProps<'nav'> {
+    items: ISidebarItem[];
+    currentUrl: string;
+    onItemClicked: (path: string) => void;
+}
 declare const Sidebar: (props: ISidebarProps) => JSX.Element;
 
-interface ISkeletonAvatarProps extends React$1.ComponentProps<'div'> {
-    indeterminate?: boolean;
-}
+interface ISkeletonAvatarProps extends React$1.ComponentProps<'div'> {
+    indeterminate?: boolean;
+}
 declare const SkeletonAvatar: (props: ISkeletonAvatarProps) => JSX.Element;
 
-interface ISkeletonTextProps extends React$1.ComponentProps<'div'> {
-    indeterminate?: boolean;
-}
+interface ISkeletonTextProps extends React$1.ComponentProps<'div'> {
+    indeterminate?: boolean;
+}
 declare const SkeletonText: (props: ISkeletonTextProps) => JSX.Element;
 
-interface ISkeletonFooterProps extends React$1.ComponentProps<'div'> {
-    indeterminate?: boolean;
-}
+interface ISkeletonFooterProps extends React$1.ComponentProps<'div'> {
+    indeterminate?: boolean;
+}
 declare const SkeletonFooter: (props: ISkeletonFooterProps) => JSX.Element;
 
-interface ISkeletonImageProps extends React$1.ComponentProps<'div'> {
-    indeterminate?: boolean;
-}
+interface ISkeletonImageProps extends React$1.ComponentProps<'div'> {
+    indeterminate?: boolean;
+}
 declare const SkeletonImage: (props: ISkeletonImageProps) => JSX.Element;
 
-interface ISnackbarProps extends ComponentProps<'div'> {
-    color?: COLOR;
-    actionText?: string;
-    onOk?: (e: React$1.MouseEvent) => void;
-}
+interface ISnackbarProps extends ComponentProps<'div'> {
+    color?: COLOR;
+    actionText?: string;
+    onOk?: (e: React$1.MouseEvent) => void;
+}
 declare const Snackbar: (props: ISnackbarProps) => JSX.Element;
 
-interface ISnackbarService {
-    show(message: React$1.ReactNode | string, options?: ISnackbarOptions): Promise<void>;
-}
-interface ISnackbarOptions {
-    actionText?: string;
-    timeout?: number;
-    color?: COLOR;
-    target?: HTMLElement;
-}
-declare class SnackbarService implements ISnackbarService {
-    private container;
-    private handler;
-    private root;
-    show(message: React$1.ReactNode | string, options?: ISnackbarOptions): Promise<void>;
-    private hide;
-}
+interface ISnackbarService {
+    show(message: React$1.ReactNode | string, options?: ISnackbarOptions): Promise<void>;
+}
+interface ISnackbarOptions {
+    actionText?: string;
+    timeout?: number;
+    color?: COLOR;
+    target?: HTMLElement;
+}
+declare class SnackbarService implements ISnackbarService {
+    private container;
+    private handler;
+    private root;
+    show(message: React$1.ReactNode | string, options?: ISnackbarOptions): Promise<void>;
+    private hide;
+}
 declare const snackbarService: SnackbarService;
 
-interface ISpeedDialProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
-    onClose?: (e: React$1.MouseEvent) => void;
-    onOpen?: (e: React$1.MouseEvent) => void;
-    open?: boolean;
-}
+interface ISpeedDialProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    onClose?: (e: React$1.MouseEvent) => void;
+    onOpen?: (e: React$1.MouseEvent) => void;
+    open?: boolean;
+}
 declare const SpeedDial: (props: ISpeedDialProps) => JSX.Element;
 
-interface ISpeedDialActionProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
-    icon: React$1.ReactNode;
-    tooltipTitle?: string;
-    color?: COLOR;
-    onClick?: (e: React$1.MouseEvent) => void;
-}
+interface ISpeedDialActionProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    icon: React$1.ReactNode;
+    tooltipTitle?: string;
+    color?: COLOR;
+    onClick?: (e: React$1.MouseEvent) => void;
+}
 declare const SpeedDialAction: (props: ISpeedDialActionProps) => JSX.Element;
 
-interface ISpeedDialIconProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
-    openIcon?: ReactElement;
-}
+interface ISpeedDialIconProps extends React$1.DetailedHTMLProps<React$1.HtmlHTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    openIcon?: ReactElement;
+}
 declare const SpeedDialIcon: (props: ISpeedDialIconProps) => JSX.Element;
 
-interface IStepProps {
-    value: string;
-    index?: number;
-    label?: ReactNode;
-    children?: ReactNode;
-    showLabel?: boolean;
-    isActive?: boolean;
-    isDone?: boolean;
-    isDisabled?: boolean;
-    isOptional?: boolean;
-    className?: string;
-    showProgressCheckIcon?: boolean;
-    onClick?: (e: {
-        event: React$1.MouseEvent;
-        value: string;
-    }) => void;
-}
+interface IStepProps {
+    value: string;
+    index?: number;
+    label?: ReactNode;
+    children?: ReactNode;
+    showLabel?: boolean;
+    isActive?: boolean;
+    isDone?: boolean;
+    isDisabled?: boolean;
+    isOptional?: boolean;
+    className?: string;
+    showProgressCheckIcon?: boolean;
+    onClick?: (e: {
+        event: React$1.MouseEvent;
+        value: string;
+    }) => void;
+}
 declare const Step: (props: IStepProps) => JSX.Element;
 
-interface IStepperProps {
-    children?: ReactElement<IStepProps> | ReactElement<IStepProps>[];
-    isLinear?: boolean;
-    isDisabled?: boolean;
-    showLabel?: boolean;
-    showProgressCheckIcon?: boolean;
-    isHorizontal?: boolean;
-    onChange?: (val: number) => void;
-    onFinish?: () => void;
-    alternativeLabel?: boolean;
-    value?: number;
-    isReadonly?: boolean;
-    showDoneButton?: boolean;
-    showResetButton?: boolean;
-    showSteps?: boolean;
-    showDots?: boolean;
-}
+interface IStepperProps {
+    children?: ReactElement<IStepProps> | ReactElement<IStepProps>[];
+    isLinear?: boolean;
+    isDisabled?: boolean;
+    showLabel?: boolean;
+    showProgressCheckIcon?: boolean;
+    isHorizontal?: boolean;
+    onChange?: (val: number) => void;
+    onFinish?: () => void;
+    alternativeLabel?: boolean;
+    value?: number;
+    isReadonly?: boolean;
+    showDoneButton?: boolean;
+    showResetButton?: boolean;
+    showSteps?: boolean;
+    showDots?: boolean;
+}
 declare const Stepper: (props: IStepperProps) => JSX.Element;
 
-interface IStepperActionsProps {
-    className?: string;
-    showDoneButton?: boolean;
-    showResetButton?: boolean;
-    isCompleted?: boolean;
-    isFirstStep?: boolean;
-    isStepOptional?: boolean;
-    onBack?: () => void;
-    onSkip?: () => void;
-    onNext?: () => void;
-    onReset?: () => void;
-}
+interface IStepperActionsProps {
+    className?: string;
+    showDoneButton?: boolean;
+    showResetButton?: boolean;
+    isCompleted?: boolean;
+    isFirstStep?: boolean;
+    isStepOptional?: boolean;
+    onBack?: () => void;
+    onSkip?: () => void;
+    onNext?: () => void;
+    onReset?: () => void;
+}
 declare const StepperActions: (props: IStepperActionsProps) => JSX.Element;
 
-interface IDot extends React$1.ComponentProps<'div'> {
-    color?: COLOR;
-    isActive?: boolean;
-}
+interface IDot extends React$1.ComponentProps<'div'> {
+    color?: COLOR;
+    isActive?: boolean;
+}
 declare const Dot: (props: IDot) => JSX.Element;
 
-interface ITableProps extends React$1.ComponentProps<'table'> {
-    striped?: boolean;
-    bordered?: boolean;
-    hover?: boolean;
-    responsive?: boolean;
-}
+interface ITableProps extends React$1.ComponentProps<'table'> {
+    striped?: boolean;
+    bordered?: boolean;
+    hover?: boolean;
+    responsive?: boolean;
+}
 declare const Table: (props: ITableProps) => JSX.Element;
 
 declare const TableRow: (props: React$1.ComponentProps<'tr'>) => JSX.Element;
@@ -829,148 +831,148 @@ declare const TableHead: (props: React$1.ComponentProps<'thead'>) => JSX.Element
 
 declare const TableBody: (props: React$1.ComponentProps<'tbody'>) => JSX.Element;
 
-interface ITableCellProps extends React$1.ComponentProps<'th'>, React$1.ComponentProps<'td'> {
-    component?: 'th';
-}
+interface ITableCellProps extends React$1.ComponentProps<'th'>, React$1.ComponentProps<'td'> {
+    component?: 'th';
+}
 declare const TableCell: (props: ITableCellProps) => JSX.Element;
 
-interface ITabProps {
-    label: ReactNode;
-    value: string;
-    disabled?: boolean;
-    className?: string;
-    onClick?: (e: {
-        event: React$1.MouseEvent;
-        value: string;
-    }) => void;
-}
+interface ITabProps {
+    label: ReactNode;
+    value: string;
+    disabled?: boolean;
+    className?: string;
+    onClick?: (e: {
+        event: React$1.MouseEvent;
+        value: string;
+    }) => void;
+}
 declare const Tab: (props: ITabProps) => JSX.Element;
 
-interface ITabsProps {
-    color?: COLOR;
-    indicatorColor?: COLOR;
-    children?: ReactElement<ITabProps> | ReactElement<ITabProps>[];
-    className?: string;
-    fixed?: boolean;
-    onChange?: (value: string) => void;
-    value?: string;
-}
+interface ITabsProps {
+    color?: COLOR;
+    indicatorColor?: COLOR;
+    children?: ReactElement<ITabProps> | ReactElement<ITabProps>[];
+    className?: string;
+    fixed?: boolean;
+    onChange?: (value: string) => void;
+    value?: string;
+}
 declare const Tabs: (props: ITabsProps) => JSX.Element;
 
-interface ITabPanelProps extends React$1.DetailedHTMLProps<React$1.HTMLProps<HTMLDivElement>, HTMLDivElement> {
-    value: string;
-    index: string;
-}
+interface ITabPanelProps extends React$1.DetailedHTMLProps<React$1.HTMLProps<HTMLDivElement>, HTMLDivElement> {
+    value: string;
+    index: string;
+}
 declare const TabPanel: (props: ITabPanelProps) => JSX.Element;
 
-interface ITextareaProps extends React$1.ComponentProps<'textarea'> {
-    error?: boolean;
-}
+interface ITextareaProps extends React$1.ComponentProps<'textarea'> {
+    error?: boolean;
+}
 declare const Textarea: (props: ITextareaProps) => JSX.Element;
 
-declare enum TIMEMODE {
-    HOUR = 0,
-    MINUTE = 1,
-    SECONDS = 2,
-    MILLISECONDS = 3
-}
-interface ITimeSelectProps {
-    value?: Date;
-    className?: string;
-    id?: string;
-    name?: string;
-    showHours?: boolean;
-    showMinutes?: boolean;
-    showSeconds?: boolean;
-    showMilliSeconds?: boolean;
-    disabled?: boolean;
-    onChange?: (val: Date) => void;
-}
+declare enum TIMEMODE {
+    HOUR = 0,
+    MINUTE = 1,
+    SECONDS = 2,
+    MILLISECONDS = 3
+}
+interface ITimeSelectProps {
+    value?: Date;
+    className?: string;
+    id?: string;
+    name?: string;
+    showHours?: boolean;
+    showMinutes?: boolean;
+    showSeconds?: boolean;
+    showMilliSeconds?: boolean;
+    disabled?: boolean;
+    onChange?: (val: Date) => void;
+}
 declare const TimeSelect: (props: ITimeSelectProps) => JSX.Element;
 
-interface IHourProps {
-    value?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface IHourProps {
+    value?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const HourSelect: (props: IHourProps) => JSX.Element;
 
-interface IMinuteProps {
-    value?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface IMinuteProps {
+    value?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const MinuteSelect: (props: IMinuteProps) => JSX.Element;
 
-interface ISecondProps {
-    value?: number;
-    className?: string;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface ISecondProps {
+    value?: number;
+    className?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const SecondSelect: (props: ISecondProps) => JSX.Element;
 
-interface IMilliSecondProps {
-    className?: string;
-    value?: number;
-    steps?: number;
-    id?: string;
-    name?: string;
-    disabled?: boolean;
-    onChange?: (val: number) => void;
-}
+interface IMilliSecondProps {
+    className?: string;
+    value?: number;
+    steps?: number;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    onChange?: (val: number) => void;
+}
 declare const MilliSecondSelect: (props: IMilliSecondProps) => JSX.Element;
 
-declare enum TooltipPlacement {
-    top = "top",
-    bottom = "bottom",
-    right = "right",
-    left = "left"
+declare enum TooltipPlacement {
+    top = "top",
+    bottom = "bottom",
+    right = "right",
+    left = "left"
 }
 
-interface ITooltipProps extends React$1.ComponentProps<'div'> {
-    placement?: TooltipPlacement;
-    text?: string;
-    delay?: number;
-    isOpen?: boolean;
-    isShowClose?: boolean;
-}
+interface ITooltipProps extends React$1.ComponentProps<'div'> {
+    placement?: TooltipPlacement;
+    text?: string;
+    delay?: number;
+    isOpen?: boolean;
+    isShowClose?: boolean;
+}
 declare const Tooltip: (props: ITooltipProps) => JSX.Element;
 
 declare const TreeView: (props: React$1.ComponentProps<'ul'>) => JSX.Element;
 
-interface ITreeItemProps extends React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLLIElement>, HTMLLIElement> {
-    nodeId?: string;
-    label?: string;
-    isExpanded?: boolean;
-    isSelected?: boolean;
-    isSelectable?: boolean;
-    onToggleExpand?: (id: string) => void;
-    onItemSelect?: (e: {
-        id: string;
-        isSelected: boolean;
-    }) => void;
-}
+interface ITreeItemProps extends React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLLIElement>, HTMLLIElement> {
+    nodeId?: string;
+    label?: string;
+    isExpanded?: boolean;
+    isSelected?: boolean;
+    isSelectable?: boolean;
+    onToggleExpand?: (id: string) => void;
+    onItemSelect?: (e: {
+        id: string;
+        isSelected: boolean;
+    }) => void;
+}
 declare const TreeItem: (props: ITreeItemProps) => JSX.Element;
 
-interface IWrapperProps {
-    as?: string;
-    children: React$1.ReactNode;
-    className?: string;
-    wrap?: boolean;
-}
-interface ITypographyProps extends React$1.ComponentProps<'span'> {
-    as?: string;
-    wrap?: boolean;
-}
+interface IWrapperProps {
+    as?: string;
+    children: React$1.ReactNode;
+    className?: string;
+    wrap?: boolean;
+}
+interface ITypographyProps extends React$1.ComponentProps<'span'> {
+    as?: string;
+    wrap?: boolean;
+}
 declare const Typography: ({ children, as, wrap, ...rest }: ITypographyProps) => JSX.Element;
 
 declare const useConstructor: (callBack: () => void) => void;
@@ -981,16 +983,16 @@ declare function useDebounce(callback: () => void, timeout: number, deps: React$
 
 declare function useHover(): (boolean | React.MutableRefObject<null>)[];
 
-declare function useMobileDetect(): {
-    isMobile: boolean;
+declare function useMobileDetect(): {
+    isMobile: boolean;
 };
 
 declare const useOnDestroy: (callBack: () => void) => void;
 
-interface IUseWindowSize {
-    width: number;
-    height: number;
-}
+interface IUseWindowSize {
+    width: number;
+    height: number;
+}
 declare function useWindowSize(): IUseWindowSize;
 
 declare const CaretDownSolidIcon: () => JSX.Element;
@@ -1021,8 +1023,8 @@ declare const TimesCircleSolidIcon: () => JSX.Element;
 
 declare const TimesSolidIcon: () => JSX.Element;
 
-interface IDictionary<T> {
-    [key: string]: T;
+interface IDictionary<T> {
+    [key: string]: T;
 }
 
-export { Alert, AppBar, AppBarTitle, AutoComplete, Backdrop, Badge, Breadcrumb, BreadcrumbItem, Button, ButtonContext, ButtonGroup, COLOR, Card, CardBody, CardFooter, CardImage, CardSubtitle, CardText, CardTitle, CaretDownSolidIcon, CheckSolidIcon, CheckSquareRegularIcon, Checkbox, ChevronDownSolidIcon, ChevronLeftSolidIcon, ChevronRightSolidIcon, ChevronUpSolidIcon, Chip, CircleSolidIcon, Column, ConditionalWrapper, CssTransition, DATEMODE, DatePicker, DateSelect, DaySelect, Dot, Drawer, EmailValidator, ExpansionPanel, ExpansionPanelContent, ExpansionPanelHeader, FileInput, FloatingActionButton, Form, FormControl, FormError, FormGroup, FormHint, FormInput, FormLabel, GlobalModal, HomeSolidIcon, HourSelect, HtmlBaseProps, HtmlInputProps, IAlertProps, IAppBarProps, IAppBarTitleProps, IAutoCompleteProps, IBackdropProps, IBadgeProps, IBreadcrumbItemProps, IBreadcrumbProps, IButtonContext, IButtonGroupProps, IButtonProps, ICheckboxProps, IChipProps, IContainerProps, IControls, IDatePickerProps, IDateSelectProps, IDaySelectProps, IDictionary, IDot, IDrawerProps, IExpansionPanelContentProps, IExpansionPanelHeaderProps, IExpansionPanelProps, IFileInputProps, IFloatingActionButtonProps, IFormAutoCompleteOptions, IFormControlConfig, IFormControlType, IFormInputError, IFormInputEvent, IFormInputOptions, IFormInputProps, IFormProps, IFormSelectOptions, IFormState, IFormTextAreaOptions, IFormValidatorType, IHourProps, IIconButtonProps, IIconProps, IListItemProps, IListProps, ILoadingIndicatorContainerProps, ILoadingIndicatorService, IMenuBodyProps, IMenuProps, IMilliSecondProps, IMinuteProps, IModalButton, IModalOptions, IModalProps$1 as IModalProps, IModalService, IMonthProps, INumberSelectProps, IPortalProps, IProgressBarProps, ISecondProps, ISelectOption, ISelectProps, ISidebarItem, ISkeletonAvatarProps, ISkeletonFooterProps, ISkeletonImageProps, ISkeletonTextProps, ISnackbarOptions, ISnackbarProps, ISnackbarService, ISpeedDialActionProps, ISpeedDialIconProps, ISpeedDialProps, IStepProps, IStepperActionsProps, IStepperProps, ITabPanelProps, ITabProps, ITableCellProps, ITableProps, ITabsProps, ITextareaProps, ITimeSelectProps, ITooltipProps, ITreeItemProps, ITypographyProps, IUseWindowSize, IWrapperProps, IYearProps, Icon, IconButton, IsEmptyValidator, IsEqualValidator, Link, List, ListItem, ListItemAction, ListItemAvatar, ListItemIcon, ListItemText, LoadingIndicator, LoadingIndicatorContainer, MODALBUTTONTYPE, MODALTYPE, MaxValidator, Menu, MenuBody, MenuDivider, MenuItem, MenuPosition, MenuToggle, MilliSecondSelect, MinValidator, MinuteSelect, Modal, ModalBody, ModalFooter, ModalHeader, MonthSelect, NumberSelect, POSITION, PlusSolidIcon, Portal, ProgressBar, Row, SIZE, STATUS, SecondSelect, Select, Sidebar, SkeletonAvatar, SkeletonFooter, SkeletonImage, SkeletonText, Snackbar, SpeedDial, SpeedDialAction, SpeedDialIcon, SpinnerSolidIcon, SquareRegularIcon, Step, Stepper, StepperActions, TIMEMODE, Tab, TabPanel, Table, TableBody, TableCell, TableHead, TableRow, Tabs, Textarea, TimeSelect, TimesCircleSolidIcon, TimesSolidIcon, Tooltip, TreeItem, TreeView, Typography, VARIANT, YearSelect, loadingIndicatorService, modalService, snackbarService, useButtonContext, useConstructor, useCssClasses, useDebounce, useHover, useMobileDetect, useOnDestroy, useWindowSize };
+export { Alert, AppBar, AppBarTitle, AutoComplete, Backdrop, Badge, Breadcrumb, BreadcrumbItem, Button, ButtonContext, ButtonGroup, COLOR, Card, CardBody, CardFooter, CardImage, CardSubtitle, CardText, CardTitle, CaretDownSolidIcon, CheckSolidIcon, CheckSquareRegularIcon, Checkbox, ChevronDownSolidIcon, ChevronLeftSolidIcon, ChevronRightSolidIcon, ChevronUpSolidIcon, Chip, CircleSolidIcon, Column, ConditionalWrapper, CssTransition, DATEMODE, DatePicker, DateSelect, DaySelect, Dot, Drawer, EmailValidator, ExpansionPanel, ExpansionPanelContent, ExpansionPanelHeader, FileInput, FloatingActionButton, Form, FormControl, FormError, FormGroup, FormHint, FormInput, FormLabel, GlobalModal, HomeSolidIcon, HourSelect, HtmlBaseProps, HtmlInputProps, IAlertProps, IAppBarProps, IAppBarTitleProps, IAutoCompleteProps, IBackdropProps, IBadgeProps, IBreadcrumbItemProps, IBreadcrumbProps, IButtonContext, IButtonGroupProps, IButtonProps, ICheckboxProps, IChipProps, IContainerProps, IControls, IDatePickerProps, IDateSelectProps, IDaySelectProps, IDictionary, IDot, IDrawerProps, IExpansionPanelContentProps, IExpansionPanelHeaderProps, IExpansionPanelProps, IFileInputProps, IFloatingActionButtonProps, IFormAutoCompleteOptions, IFormControlConfig, IFormControlType, IFormInputError, IFormInputEvent, IFormInputOptions, IFormInputProps, IFormProps, IFormSelectOptions, IFormState, IFormTextAreaOptions, IFormValidatorType, IHourProps, IIconButtonProps, IIconProps, IListItemProps, IListProps, ILoadingIndicatorContainerProps, ILoadingIndicatorService, IMenuBodyProps, IMenuProps, IMilliSecondProps, IMinuteProps, IModalButton, IModalOptions, IModalProps$1 as IModalProps, IModalService, IMonthProps, INumberSelectProps, IPortalProps, IProgressBarProps, ISecondProps, ISelectOption, ISelectProps, ISidebarItem, ISkeletonAvatarProps, ISkeletonFooterProps, ISkeletonImageProps, ISkeletonTextProps, ISnackbarOptions, ISnackbarProps, ISnackbarService, ISpeedDialActionProps, ISpeedDialIconProps, ISpeedDialProps, IStepProps, IStepperActionsProps, IStepperProps, ITabPanelProps, ITabProps, ITableCellProps, ITableProps, ITabsProps, ITextareaProps, ITimeSelectProps, ITooltipProps, ITreeItemProps, ITypographyProps, IUseWindowSize, IWrapperProps, IYearProps, Icon, IconButton, IsEmptyValidator, IsEqualValidator, Link, List, ListItem, ListItemAction, ListItemAvatar, ListItemIcon, ListItemText, LoadingIndicator, LoadingIndicatorContainer, MODALBUTTONTYPE, MODALTYPE, MaxValidator, Menu, MenuBody, MenuDivider, MenuItem, MenuPosition, MenuToggle, MilliSecondSelect, MinValidator, MinuteSelect, Modal, ModalBody, ModalFooter, ModalHeader, MonthSelect, NumberSelect, POSITION, PlusSolidIcon, Portal, ProgressBar, Row, SIZE, STATUS, SecondSelect, Select, Sidebar, SkeletonAvatar, SkeletonFooter, SkeletonImage, SkeletonText, Snackbar, SpeedDial, SpeedDialAction, SpeedDialIcon, SpinnerSolidIcon, SquareRegularIcon, Step, Stepper, StepperActions, TIMEMODE, Tab, TabPanel, Table, TableBody, TableCell, TableHead, TableRow, Tabs, Textarea, TimeSelect, TimesCircleSolidIcon, TimesSolidIcon, Tooltip, TooltipPlacement, TreeItem, TreeView, Typography, VARIANT, YearSelect, loadingIndicatorService, modalService, snackbarService, useButtonContext, useConstructor, useCssClasses, useDebounce, useHover, useMobileDetect, useOnDestroy, useWindowSize };