react-asc 25.5.5 → 25.5.6

package/index.d.ts

@@ -0,0 +1,1028 @@
+/// <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 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;
+}
+declare const AppBar: (props: IAppBarProps) => JSX.Element;
+
+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;
+}
+declare const AutoComplete: (props: IAutoCompleteProps) => JSX.Element;
+
+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;
+}
+declare const Badge: (props: IBadgeProps) => JSX.Element;
+
+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;
+}
+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;
+}
+declare const Button: React$1.FunctionComponent<IButtonProps>;
+
+interface IButtonContext {
+    color: COLOR | null;
+}
+declare const ButtonContext: React.Context<IButtonContext>;
+declare const useButtonContext: () => IButtonContext;
+
+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;
+}
+declare const Card: (props: ICardProps) => JSX.Element;
+
+declare const CardBody: (props: React$1.ComponentProps<'div'>) => JSX.Element;
+
+declare const CardFooter: (props: React$1.ComponentProps<'div'>) => JSX.Element;
+
+declare const CardSubtitle: (props: React$1.ComponentProps<'div'>) => JSX.Element;
+
+declare const CardText: (props: React$1.ComponentProps<'p'>) => JSX.Element;
+
+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;
+}
+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;
+}
+declare const Chip: (props: IChipProps) => JSX.Element;
+
+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;
+}
+declare const CssTransition: (props: ICssTransitionProps) => JSX.Element;
+
+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 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;
+}
+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;
+}
+declare const DaySelect: (props: IDaySelectProps) => JSX.Element;
+
+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;
+}
+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;
+}
+declare const ExpansionPanel: (props: IExpansionPanelProps) => JSX.Element;
+
+interface IExpansionPanelHeaderProps {
+    onClick?: (event: React$1.MouseEvent) => void;
+    children?: ReactNode;
+    isExpanded: boolean;
+}
+declare const ExpansionPanelHeader: (props: IExpansionPanelHeaderProps) => JSX.Element;
+
+interface IExpansionPanelContentProps {
+    children?: ReactNode;
+}
+declare const ExpansionPanelContent: ({ children }: IExpansionPanelContentProps) => JSX.Element;
+
+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;
+}
+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[];
+}
+declare const FormError: (props: IFormErrorProps) => JSX.Element;
+
+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>;
+}
+declare const FormInput: (props: IFormInputProps) => JSX.Element;
+
+declare const FormLabel: ({ children, className, htmlFor, ...rest }: React$1.ComponentProps<'label'>) => JSX.Element;
+
+declare const EmailValidator: (value: string) => boolean;
+
+declare const IsEmptyValidator: (value: string) => boolean;
+
+declare const IsEqualValidator: (valueA: unknown, valueB: unknown) => boolean;
+
+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;
+}
+declare const Column: (props: IColProps) => JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const List: (props: IListProps) => JSX.Element;
+
+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;
+}
+declare const ListItemAvatar: ({ avatar, ...rest }: IListItemAvatarProps) => JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const loadingIndicatorService: LoadingIndicatorService;
+
+declare 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;
+}
+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;
+}
+declare const MenuBody: (props: IMenuBodyProps) => JSX.Element;
+
+declare const MenuItem: (props: IListItemProps) => JSX.Element;
+
+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;
+}
+declare const Modal: (props: IModalProps$1) => JSX.Element;
+
+interface IModalBodyProps {
+    children?: ReactNode;
+}
+declare const ModalBody: ({ children }: IModalBodyProps) => JSX.Element;
+
+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;
+}
+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 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;
+}
+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;
+}
+declare const NumberSelect: (props: INumberSelectProps) => JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const Sidebar: (props: ISidebarProps) => JSX.Element;
+
+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;
+}
+declare const SkeletonText: (props: ISkeletonTextProps) => JSX.Element;
+
+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;
+}
+declare const SkeletonImage: (props: ISkeletonImageProps) => JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const SpeedDialAction: (props: ISpeedDialActionProps) => JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const StepperActions: (props: IStepperActionsProps) => JSX.Element;
+
+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;
+}
+declare const Table: (props: ITableProps) => JSX.Element;
+
+declare const TableRow: (props: React$1.ComponentProps<'tr'>) => JSX.Element;
+
+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';
+}
+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;
+}
+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;
+}
+declare const Tabs: (props: ITabsProps) => JSX.Element;
+
+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;
+}
+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 const TimeSelect: (props: ITimeSelectProps) => JSX.Element;
+
+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;
+}
+declare const MinuteSelect: (props: IMinuteProps) => JSX.Element;
+
+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;
+}
+declare const MilliSecondSelect: (props: IMilliSecondProps) => JSX.Element;
+
+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;
+}
+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;
+}
+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;
+}
+declare const Typography: ({ children, as, wrap, ...rest }: ITypographyProps) => JSX.Element;
+
+declare const useConstructor: (callBack: () => void) => void;
+
+declare function useCssClasses(cssClasses: string[]): string[];
+
+declare function useDebounce(callback: () => void, timeout: number, deps: React$1.DependencyList): void;
+
+declare function useHover(): (boolean | React.MutableRefObject<null>)[];
+
+declare function useMobileDetect(): {
+    isMobile: boolean;
+};
+
+declare const useOnDestroy: (callBack: () => void) => void;
+
+interface IUseWindowSize {
+    width: number;
+    height: number;
+}
+declare function useWindowSize(): IUseWindowSize;
+
+declare const CaretDownSolidIcon: () => JSX.Element;
+
+declare const CheckSolidIcon: () => JSX.Element;
+
+declare const CheckSquareRegularIcon: () => JSX.Element;
+
+declare const ChevronDownSolidIcon: () => JSX.Element;
+
+declare const ChevronLeftSolidIcon: () => JSX.Element;
+
+declare const ChevronRightSolidIcon: () => JSX.Element;
+
+declare const ChevronUpSolidIcon: () => JSX.Element;
+
+declare const CircleSolidIcon: () => JSX.Element;
+
+declare const HomeSolidIcon: () => JSX.Element;
+
+declare const PlusSolidIcon: () => JSX.Element;
+
+declare const SpinnerSolidIcon: () => JSX.Element;
+
+declare const SquareRegularIcon: () => JSX.Element;
+
+declare const TimesCircleSolidIcon: () => JSX.Element;
+
+declare const TimesSolidIcon: () => JSX.Element;
+
+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 };