/// <reference types="react" />
import * as react from 'react';
import react__default, { ReactNode } from 'react';

interface LoadingProps {
    classPrefix?: string;
    type?: 'dual-ring' | 'bouncing-balls' | 'cradle' | 'wave';
    fullScreen?: boolean;
    width?: string | number;
    height?: string | number;
    style?: {
        [index: string]: string;
    };
    className?: string;
}

declare type ButtonProps = {
    text?: string;
    type?: 'submit' | 'reset' | 'button' | undefined;
    loading?: boolean;
    loadingEffect?: 'default' | 'simple';
    loadingType?: LoadingProps['type'];
    loadingClassPrefix?: string;
    loadingCustomChild?: ReactNode;
    width?: string | number;
    height?: string | number;
    size?: 'small' | 'medium' | 'large';
    widthParent?: boolean;
    rounded?: boolean;
    disabled?: boolean;
    outline?: boolean;
    loadingCircleColor?: string;
    className?: string;
    textClass?: string;
    style?: {
        [index: string]: string;
    };
    textStyle?: {
        [index: string]: string;
    };
    loadingOuterCircleStyle?: {
        [index: string]: string;
    };
    loadingInnerCircleStyle?: {
        [index: string]: string;
    };
    children?: ReactNode;
    onClick?: () => void;
};

declare const Button: (props: ButtonProps) => JSX.Element;

interface ProgressbarProps {
    value: string | number;
    text?: string;
    hideValue?: boolean;
    animation?: 'flash' | 'flow';
    progressColor?: string;
    flowParticleColor?: string;
    flasherColor?: string;
    bgColor?: string;
    textColor?: string;
    textFontSize?: string;
    progressStyle?: {
        [index: string]: string;
    };
    textStyle?: {
        [index: string]: string;
    };
    flowParticleStyle?: {
        [index: string]: string;
    };
    flasherStyle?: {
        [index: string]: string;
    };
    progressClass?: string;
    textClass?: string;
    flowParticleClass?: string;
    flasherClass?: string;
    style?: {
        [index: string]: string;
    };
    className?: string;
}

declare const Progressbar: (props: ProgressbarProps) => JSX.Element;

interface NotifyPorps {
    position?: 'top' | 'top-left' | 'top-right' | 'bottom' | 'bottom-left' | 'bottom-right' | 'center';
    duration?: number;
    animation?: ToggleAnimations;
}
interface NotifyTextBoxProps {
    text: string;
    type?: 'success' | 'error' | '';
    duration: number;
    animation: ToggleAnimations;
    parentEl: HTMLElement;
}

declare type StyleObject = {
    [index: string]: string;
};
declare type ToggleAnimations = 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'fade' | 'scale' | 'rotate';

interface SheetProps {
    displayModel?: [boolean, (display: boolean) => void];
    children?: ReactNode;
    id?: string;
    type?: 'center' | 'bottom' | 'top' | 'left' | 'right';
    width?: string | number;
    height?: string | number;
    minHeight?: string | number;
    animation?: ToggleAnimations;
    title?: string;
    dismissDisabled?: boolean;
    noHeader?: boolean;
    onBackdropClick?: () => void;
    onDismiss?: () => void;
    onDisplay?: () => void;
    bodyStyle?: {
        [index: string]: string;
    };
    backdropStyle?: {
        [index: string]: string;
    };
    bodyClass?: string;
    backdropClass?: string;
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare type Sheet = {
    show: () => void;
    hide: () => void;
    toggle: () => void;
};
declare const Sheet: react.ForwardRefExoticComponent<SheetProps & react.RefAttributes<unknown>>;

interface StepperProps {
    onChange?: (value: number) => void;
    value?: number;
    model?: [number, (value: number) => void];
    min?: number;
    max?: number;
    editable?: boolean;
    vertical?: boolean;
    chevron?: boolean;
    width?: number | string;
    height?: number | string;
    incStyle?: {
        [index: string]: string;
    };
    decStyle?: {
        [index: string]: string;
    };
    numberStyle?: {
        [index: string]: string;
    };
    incClass?: string;
    decClass?: string;
    numberClass?: string;
    style?: {
        [index: string]: string;
    };
    className?: string;
}

declare const Stepper: (props: StepperProps) => JSX.Element;

declare const Notify: (props: NotifyPorps) => JSX.Element;

interface ConfirmProps {
    confirmButtonText?: string;
    cancelButtonText?: string;
    animation?: ToggleAnimations;
    type?: SheetProps['type'];
}

declare const Confirm: (props: ConfirmProps) => JSX.Element;

interface PickerProps {
    options?: (string | number | (string | number)[])[];
    stopAtEnd?: boolean;
    optionSize?: number;
    mouseMoveRatio?: number;
    touchMoveRatio?: number;
    horizontal?: boolean;
    height?: number;
    width?: number;
    noSelectedFrame?: boolean;
    startCenter?: boolean;
    getValue?: boolean;
    arrow?: boolean;
    children?: ReactNode;
    selectedFrameClass?: string;
    optionClass?: string;
    selectedFrameStyle?: {
        [index: string]: string;
    };
    optionStyle?: {
        [index: string]: string;
    };
    style?: {
        [index: string]: string;
    };
    className?: string;
    value?: any;
    onChange?: (value: any) => void;
    model?: [any, (value: any) => void];
}

declare const Picker: (props: PickerProps) => JSX.Element;

interface CropperProps {
    image: File | string;
    output?: {
        width: number;
        height: number;
        type: string;
    };
    cropper?: {
        width: number;
        height: number;
    };
    onCrop: (output: any) => void;
}

declare const Cropper: (props: CropperProps) => JSX.Element;

interface CarouselProps {
    children?: ReactNode;
    model?: [number, (value: number) => void];
    itemsPerView?: number;
    itemsPerSlide?: number;
    eachItemMargin?: number;
    eachItemHeight?: number;
    duration?: number;
    auto?: boolean;
    stopAtEnd?: boolean;
    noIndicator?: boolean;
    responsive?: {
        [index: number]: number;
    };
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const Carousel: (props: CarouselProps) => JSX.Element;

interface InputBasicProps<T> {
    onChange?: (value: T) => void;
    value?: T;
    model?: [T, (value: T) => void];
    title?: string;
    placeholder?: string;
    required?: boolean;
    readOnly?: boolean;
    autoFocus?: boolean;
    focus?: boolean;
    delay?: number | boolean;
    type?: "text" | "number" | "tel" | "email" | "password";
    icon?: string;
    passwordVisibilityToggler?: boolean;
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const InputBasic: <T extends string | number | undefined>(props: InputBasicProps<T>) => JSX.Element;

interface InputCheckboxProps<T> {
    value?: T;
    onChange?: (val: T) => void;
    model?: [T, (val: T) => void];
    title: string | number;
    checkedValue?: string | number;
    name?: string;
    binary?: boolean;
    style?: {
        [index: string]: string;
    };
    checkmarkStyle?: {
        [index: string]: string;
    };
    titleStyle?: {
        [index: string]: string;
    };
    className?: string;
    titleClass?: string;
    checkmarkClass?: string;
}

declare const InputCheckbox: <T extends string | number | boolean>(props: InputCheckboxProps<T>) => JSX.Element;

interface InputToggleProps<T> {
    model?: [T, (value: T) => void];
    value?: T;
    onChange?: (value: T) => void;
    defaultValue: (string | number)[];
    activeValue: (string | number)[];
    rectangle?: boolean;
    togglerStyle?: {
        [index: string]: string;
    };
    pointerStyle?: {
        [index: string]: string;
    };
    activeValueStyle?: {
        [index: string]: string;
    };
    defaultValueStyle?: {
        [index: string]: string;
    };
    defaultValueClass?: string;
    activeValueClass?: string;
    pointerClass?: string;
    togglerClass?: string;
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const InputToggle: <T extends string | number | undefined>(props: InputToggleProps<T>) => JSX.Element;

interface TimepickerProps {
    value?: string;
    onChange?: (value: string) => void;
    model?: [string, (value: string) => void];
    format?: string;
    hourType?: string;
}

declare type Timepicker = {
    clear: () => void;
};
declare const Timepicker: react.ForwardRefExoticComponent<TimepickerProps & react.RefAttributes<unknown>>;

interface InputRadioProps<T> {
    value?: T;
    onChange?: (value: T) => void;
    model?: [T, (value: T) => void];
    title: string | number;
    checkedValue: string | number;
    name?: string;
    style?: {
        [index: string]: string;
    };
    checkmarkStyle?: {
        [index: string]: string;
    };
    titleStyle?: {
        [index: string]: string;
    };
    className?: string;
    titleClass?: string;
    checkmarkClass?: string;
}

declare const InputRadio: <T extends string | number>(props: InputRadioProps<T>) => JSX.Element;

interface InputRangeProps<T> {
    value?: T;
    onChange?: (value: T) => void;
    model?: [T, (value: T) => void];
    min?: number;
    max?: number;
    step?: number;
    double?: boolean;
    outputDisplay?: 'none' | 'up';
    outputOneStyle?: {
        [index: string]: string;
    };
    outputTwoStyle?: {
        [index: string]: string;
    };
    fullRangeStyle?: {
        [index: string]: string;
    };
    selectedRangeStyle?: {
        [index: string]: string;
    };
    inputOneStyle?: {
        [index: string]: string;
    };
    inputTwoStyle?: {
        [index: string]: string;
    };
    outputOneClass?: string;
    outputTwoClass?: string;
    fullRangeClass?: string;
    selectedRangeClass?: string;
    inputOneClass?: string;
    inputTwoClass?: string;
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const InputRange: <T extends number | number[] | undefined>(props: InputRangeProps<T>) => JSX.Element;

interface InputTextareaProps<T> {
    value?: T;
    onChange?: (value: T) => void;
    model?: [T, (value: T) => void];
    title?: string;
    placeholder?: string;
    cols?: number;
    rows?: number;
    required?: boolean;
    readOnly?: boolean;
    autoFocus?: boolean;
    focus?: boolean;
    icon?: string;
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const InputTextarea: <T extends string | number | undefined>(props: InputTextareaProps<T>) => JSX.Element;

interface InputSelectProps<T> {
    value?: T;
    onChange?: (value: T) => void;
    model?: [T, (value: T) => void];
    options?: (number | string)[][];
    title?: string;
    placeholder?: string;
    multi?: boolean;
    icon?: string;
    displayType?: 'dropdown' | 'sheet-bottom' | 'sheet-center';
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const InputSelect: <T extends string | number | (string | number)[]>(props: InputSelectProps<T>) => JSX.Element;

declare type PreviewSize = {
    width?: number | string;
    height?: number | string;
    maxWidth?: number | string;
    maxHeight?: number | string;
};
declare type FinalOutputSingle = string | File;
declare type FinalOutputMulti = (string | File)[];
interface InputFileProps<T> {
    value?: T;
    onChange?: (value: T) => void;
    model?: [T, (value: T) => void];
    title?: string;
    placeholder?: string;
    icon?: string;
    required?: boolean;
    accept?: string;
    video?: boolean;
    audio?: boolean;
    image?: boolean;
    preview?: boolean;
    multi?: boolean;
    maxSize?: number;
    dragDrop?: boolean;
    cropper?: boolean;
    previewSize?: PreviewSize;
    className?: string;
    style?: {
        [index: string]: string;
    };
}

declare const InputFile: <T extends string | string[] | File | File[] | undefined>(props: InputFileProps<T>) => JSX.Element;

interface InputDateProps {
    model?: [string, (val: string) => void];
    value?: string;
    onChange?: (val: string) => void;
    title?: string;
    icon?: string;
    placeholder?: string;
    format?: string;
    inputLocale?: string;
    outputLocale?: string;
    timepicker?: boolean;
    timepickerHourType?: string;
    defaultToday?: boolean;
    className?: string;
    style?: {
        [index: string]: string;
    };
}
declare type Calendar = {
    monthNames: string[];
    weekDayNames: string[];
    weekDayNamesToFindOffset: string[];
};
declare type CurrentCalendarPage = {
    year: number;
    month: number;
    monthNames: string[];
    weekDayNames: string[];
    weekDayNamesToFindOffset: string[];
};
declare type TodayDate = {
    year: number;
    month: number;
    day: number;
    date: string;
};
declare type SelectedDate = {
    year: number;
    month: number;
    day: number;
};

declare const InputDate: (props: InputDateProps) => JSX.Element;

declare const Loading: (props: LoadingProps) => JSX.Element;

interface RowProps {
    children?: ReactNode;
    className?: string;
    style?: {
        [index: string]: string;
    };
}
declare const Row: (props: RowProps) => JSX.Element;

interface ColProps {
    children?: ReactNode;
    width?: string;
    className?: string;
    style?: {
        [index: string]: string;
    };
}
declare const Col: (props: ColProps) => JSX.Element;

interface TabBarProps<T> {
    model?: [T, (value: T) => void];
    tabs?: string[] | ReactNode[] | (string | ReactNode)[] | (string | ReactNode | number)[][];
    position?: 'default' | 'fixed-bottom' | 'fixed-top';
    indicatorType?: 'none' | 'box' | 'line-top' | 'line-bottom';
    width?: number | string;
    responsiveWidth?: string;
    tabStyle?: {
        [index: string]: string;
    };
    indicatorStyle?: {
        [index: string]: string;
    };
    activeTabStyle?: {
        [index: string]: string;
    };
    tabClass?: string;
    indicatorClass?: string;
    activeTabClass?: string;
    indicatorColor?: string;
    tabBarBgColor?: string;
    tabColor?: string;
    activeTabColor?: string;
    style?: {
        [index: string]: string;
    };
    className?: string;
}

declare const TabBar: <T extends string | number>(props: TabBarProps<T>) => JSX.Element;

declare type CustomClickProps = {
    onClick?: (e: MouseEvent | TouchEvent) => void;
    onLongClick?: (e: MouseEvent | TouchEvent) => void;
    longClickDuration?: number;
    children: react__default.ReactNode;
    style?: {
        [index: string]: string;
    };
    className?: string;
};

declare const CustomClick: (props: CustomClickProps) => JSX.Element;

interface ScrollProps {
    children?: ReactNode;
    hideScrollbar?: boolean;
    vertical?: boolean;
    grabScrollClass?: string;
    grabScrollStyle?: StyleObject;
}

declare const GrabScroll: react__default.ForwardRefExoticComponent<ScrollProps & react__default.RefAttributes<unknown>>;

interface LayoutProps {
    children?: ReactNode;
    sidebar?: ReactNode;
    topbar?: ReactNode;
    sidebarPosition?: SidebarPositions;
    sidebarStyle?: StyleObject;
    contentStyle?: StyleObject;
    layoutStyle?: StyleObject;
    sidebarClass?: string;
    contentClass?: string;
    layoutClass?: string;
}
declare enum SidebarPositions {
    Start = "start",
    End = "end"
}
declare const Layout: (props: LayoutProps) => JSX.Element;

declare type SheetTypes = SheetProps['type'];
declare const Gamon: {
    notify: (text: string | string[], type?: NotifyTextBoxProps['type'], duration?: number, animation?: ToggleAnimations) => void;
    confirm: (title: string, text: string, confirmCallback: () => void, cancelCallback?: () => void, animation?: ToggleAnimations, type?: SheetTypes, confirmButtonText?: string, cancelButtonText?: string) => void;
};

export { Button, ButtonProps, Calendar, Carousel, CarouselProps, Col, Confirm, ConfirmProps, Cropper, CropperProps, CurrentCalendarPage, CustomClick, CustomClickProps, FinalOutputMulti, FinalOutputSingle, Gamon, GrabScroll, InputBasic, InputBasicProps, InputCheckbox, InputCheckboxProps, InputDate, InputDateProps, InputFile, InputFileProps, InputRadio, InputRadioProps, InputRange, InputRangeProps, InputSelect, InputSelectProps, InputTextarea, InputTextareaProps, InputToggle, InputToggleProps, Layout, Loading, LoadingProps, Notify, NotifyPorps, NotifyTextBoxProps, Picker, PickerProps, PreviewSize, Progressbar, ProgressbarProps, Row, SelectedDate, Sheet, SheetProps, Stepper, StepperProps, StyleObject, TabBar, TabBarProps, Timepicker, TimepickerProps, TodayDate, ToggleAnimations };