import { Jsmin } from '@mingoo/jsmin';
import { FontAwesomeIconProps } from '@fortawesome/react-fontawesome';
import { IconDefinition } from "@fortawesome/fontawesome-common-types";
import * as FontawesomeCore from '@fortawesome/fontawesome-svg-core';
import React from 'react';
import ReactDOM from 'react-dom';
import * as ReactRouterDOM from 'react-router-dom';
import { ReactElement, Device, Browser } from './_';
import { TagProps } from './property';
export declare namespace config {
    interface Methods {
        sessionUID: string;
        appRootID: string;
        appRoot: HTMLElement;
        themeColor: TagProps.ThemeColor;
        darkMode: TagProps.DarkMode;
        roundness: TagProps.Roundness;
        device: {
            deviceIs: Device;
            browserIs: Browser;
            isBreakpoint(): boolean;
            isPhonepoint(): boolean;
            isSystemDarkmode(): boolean;
            isPhone: boolean;
            isTouchDevice: boolean;
            isIOS: boolean;
        };
        update: {
            themeColor(value: TagProps.ThemeColor): void;
            darkMode(value: TagProps.DarkMode): void;
            roundness(value: TagProps.Roundness): void;
        };
        variables: {
            darkmodeColors: {
                light: string;
                dark: string;
                dim: string;
                auto(): string;
            };
            themeColors: {
                [key in TagProps.ThemeColor]: {
                    alfa(alfa?: number): string;
                    isBrand: boolean;
                    isAvocado: boolean;
                };
            };
        };
        readExtraCDN(url: string): Promise<boolean>;
    }
}
export declare namespace global {
    type LaunchRootInput = {
        baseElement?: HTMLElement;
    };
    type LaunchReactApplicationInput = {
        baseElement?: HTMLElement | string;
        reactElement: ReactElement;
        nonRouter?: boolean;
        isRoot?: boolean;
        appearances?: {
            roundness?: TagProps.Roundness;
            themeColor?: TagProps.ThemeColor;
            darkMode?: TagProps.DarkMode;
        };
    };
    type useStoreParams = {
        set(params: {
            key: string;
            value: any;
            privateKey?: string;
        }): boolean;
        update(params: {
            key: string;
            value: any;
            privateKey?: string;
        }): boolean;
        get(key: string, privateKey?: string): any;
        delete(key: string, privateKey?: string): boolean;
    };
    type useRecycleParams = {
        set(key: string): string;
        do(key: string): void;
    };
    type PageTransitParams = {
        open(url: string): void;
        pushSync(url: string): void;
        pushAsync(url: string): void;
        push(url: string, newTab?: boolean): void;
        back(): void;
    };
    namespace StyleConverter {
        type ReadStyleSet = {
            <T>(params: T): T;
        };
        type ToClassName = {
            <T>(params: T): T;
        };
    }
    interface Methods {
        React: typeof React;
        ReactDOM: typeof ReactDOM;
        ReactRouterDOM: typeof ReactRouterDOM;
        StyleConverter: {
            ReadStyleSet: StyleConverter.ReadStyleSet;
            ToClassName: StyleConverter.ToClassName;
        };
        pageTransit: PageTransitParams;
        useStore: global.useStoreParams;
        useRecycle: global.useRecycleParams;
        LaunchRoot(params: global.LaunchRootInput): void;
        LaunchReactApplication(params: global.LaunchReactApplicationInput): void;
    }
}
export declare namespace atoms {
    type BoxInput = TagProps.BasicElement & {
        children?: ReactElement;
    } & React.HTMLAttributes<HTMLDivElement>;
    type SpanProps = TagProps.BasicElement & {
        children?: ReactElement;
    } & React.HTMLAttributes<HTMLSpanElement>;
    type ParagraphProps = TagProps.BasicElement & {
        children?: ReactElement;
    } & React.HTMLAttributes<HTMLParagraphElement>;
    type FlexProps = TagProps.BasicElement & {
        children?: ReactElement;
    } & React.HTMLAttributes<HTMLDivElement>;
    type GridProps = TagProps.BasicElement & {
        children: ReactElement;
        onClick?: {
            (event: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
        };
    } & React.HTMLAttributes<HTMLDivElement>;
    namespace FAI {
        type Method = React.FC<FAIParams> & Shortcuts;
        type FAIParams = TagProps.BasicElement & {
            icon: FontawesomeCore.IconProp | IconDefinition;
            iconParams?: Omit<FontAwesomeIconProps, 'icon'>;
        };
        type Shortcuts = {
            [key in ShortCutNames]: React.FC<Omit<FAIParams, 'icon'>>;
        };
        type ShortCutNames = 'User' | 'Times' | 'AngleRight' | 'AngleLeft' | 'AngleUp' | 'AngleDown' | 'ChevronLeft' | 'ChevronRight' | 'ChevronUp' | 'ChevronDown' | 'CaretLeft' | 'CaretRight' | 'CaretUp' | 'CaretDown' | 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown' | 'Rotate' | 'Redo' | 'Check' | 'CheckCircle' | 'Question' | 'QuestionCircle' | 'Exclamation' | 'ExclamationTriangle' | 'Home' | 'Share' | 'Search' | 'YenSign' | 'Heart' | 'Star' | 'Edit' | 'Pen' | 'Copy' | 'File' | 'TrashAlt' | 'Bars' | 'Download' | 'Link' | 'LinkSlash' | 'ExternalLinkAlt' | 'Gear' | 'Plus' | 'Minus' | 'EllipsisH' | 'EllipsisV' | 'PaperPlane' | 'Image';
    }
    namespace Image {
        type Methods = React.FC<CompInput> & DefaultImages;
        type CompInput = TagProps.BasicElement & {
            src: string;
            alt?: string;
            showExpand?: boolean | string;
        } & React.HTMLAttributes<HTMLImageElement>;
        type DefaultImages = {
            uri: {
                mingooIcon: string;
                comunIcon: string;
                comunIconClear: string;
                defaultIcon(type: 'image' | 'object' | 'user' | 'group' | 'store'): string;
            };
        };
    }
    namespace Logos {
        type Methods = {
            Icon: (params: Params) => JSX.Element;
            Title: (params: Params) => JSX.Element;
            Brands: {
                MingooIcon: (params: DefaultLogo) => JSX.Element;
                MingooTitle: (params: DefaultLogo) => JSX.Element;
                MingooLogoH: (params: DefaultLogo) => JSX.Element;
                MingooLogoV: (params: DefaultLogo) => JSX.Element;
                ComunIcon: (params: DefaultLogo) => JSX.Element;
                ComunTitle: (params: DefaultLogo) => JSX.Element;
                ComunLogoH: (params: DefaultLogo) => JSX.Element;
                ComunLogoV: (params: DefaultLogo) => JSX.Element;
                Google: (params: DefaultLogo) => JSX.Element;
                Facebook: (params: DefaultLogo) => JSX.Element;
                Twitter: (params: DefaultLogo) => JSX.Element;
                LINE: (params: DefaultLogo) => JSX.Element;
            };
        };
        type Params = TagProps.BasicElement & {
            size?: 'S' | 'R' | 'L' | '2L' | '3L';
            color?: 'normal' | 'white';
            children?: ReactElement | React.FC<any>;
        };
        type DefaultLogo = TagProps.BasicElement & {
            size?: 'S' | 'R' | 'L' | '2L' | '3L';
            color?: 'normal' | 'white';
        };
    }
    type PlaceholderParams = atoms.BoxInput & {
        color?: 'cloud' | 'white';
    };
    type Methods = {
        Box: React.FC<atoms.BoxInput>;
        Flex: React.FC<atoms.FlexProps>;
        FlexBr: React.FC<TagProps.Params>;
        Placeholder: React.FC<PlaceholderParams>;
        Grid: React.FC<atoms.GridProps>;
        FAI: FAI.Method;
        Span: React.FC<atoms.SpanProps>;
        Paragraph: React.FC<atoms.ParagraphProps>;
        Img: atoms.Image.Methods;
        Logo: Logos.Methods;
    };
}
export declare namespace mols {
    namespace Accordion {
        type Params = {
            defaultOpen?: boolean;
            override?: boolean;
            accordionID?: string;
            slideAnimation?: 'none' | 'fast' | 'slow';
            children: ReactElement;
            onToggleEvent?: {
                (open: boolean): void;
            };
        } & atoms.BoxInput;
        type FNParams = {
            fn: {
                open(accordionID: string): void;
                close(accordionID: string): void;
                toggle(accordionID: string): void;
            };
        };
        type SetParams = React.FC<Params> & FNParams;
    }
    namespace List {
        type Params = TagProps.BasicElement & {
            rowStyles?: TagProps.Params;
            rows: RowsParams[];
        };
        type RowsParams = {
            children: ReactElement;
        } & TagProps.BasicElement;
    }
    type LinkifyTextProps = {
        text: string;
        placeholder?: ReactElement;
    };
    type Methods = {
        List: React.FC<mols.List.Params>;
        Accordion: mols.Accordion.SetParams;
        LinkifyText: React.FC<mols.LinkifyTextProps>;
        Text: {
            NowrapSpan: React.FC<atoms.SpanProps>;
            Title: React.FC<atoms.BoxInput>;
            SubTitle: React.FC<atoms.BoxInput>;
            ThirdTitle: React.FC<atoms.BoxInput>;
            Paragraph: React.FC<atoms.BoxInput>;
            Normal: React.FC<atoms.BoxInput>;
            Description: React.FC<atoms.BoxInput>;
            Supplement: React.FC<atoms.BoxInput>;
        };
        Column: React.FC<atoms.FlexProps>;
        Row: {
            Center: React.FC<atoms.FlexProps>;
            Left: React.FC<atoms.FlexProps>;
            Right: React.FC<atoms.FlexProps>;
            Separate: React.FC<atoms.FlexProps>;
        };
    };
}
export declare namespace orgs {
    type Methods = {};
}
export declare namespace temps {
    type Methods = {};
}
export declare namespace fn {
    namespace Layout {
        type Methods = {
            PageViewController: React.FC<PageViewController.Params>;
            TabBar: React.FC<TabBar.Params>;
            Plate: React.FC<Plate.Params>;
            SwipeView: React.FC<SwipeView.Params>;
            PageRouter: React.FC<PageRouter.RouterProps>;
            PageNotFound: React.FC<{}>;
            RootViewController: RootViewController.Methods;
        };
        namespace PageViewController {
            type Params = {
                viewIndex: number;
                views: ReactElement[];
                wrapper?: {
                    (view: ReactElement): ReactElement;
                };
            };
        }
        namespace TabBar {
            type Params = {
                tabIndex: number;
                tabs: ReactElement[];
                onTabChange?: {
                    (index: number): void;
                };
                componentDidMount?: {
                    (): void;
                };
            } & TagProps.BasicElement;
        }
        namespace Plate {
            type Params = {
                size?: 'XS' | 'S' | 'R' | 'L' | 'XL' | 'MAX';
            } & atoms.BoxInput;
        }
        namespace SwipeView {
            type Params = TagProps.BasicElement & {
                slideIndex?: number;
                slides: ReactElement[];
                wrapper?: {
                    (slide: ReactElement): ReactElement;
                };
                options?: {
                    onSlideCallback?: {
                        (index: number): void;
                    };
                    visibilitySurroundSlide?: boolean;
                    autoSwipeSeconds?: number;
                    loop?: boolean;
                    disableMousedrag?: boolean;
                    disableTouch?: boolean;
                };
            };
        }
        namespace PageRouter {
            type RoutesProps = {
                path: string;
                content: ReactElement;
            };
            type Callbacks = {
                beforeCallBack?: {
                    (pathName: string): void;
                };
                afterCallBack?: {
                    (pathName: string): void;
                };
                afterFirstCallBack?: {
                    (pathName: string): void;
                };
            };
            type RoutesSwitchProps = {
                routes: RoutesProps[];
            } & Callbacks;
            type RouterProps = {
                pages: RoutesProps[];
            } & Callbacks;
        }
        namespace RootViewController {
            type Methods = {
                Base: React.FC<RootViewController.BaseParams>;
                TopNavigation: React.FC<atoms.FlexProps>;
                SideNavigation: React.FC<atoms.FlexProps & {
                    baseStyles?: TagProps.Params;
                }>;
                FooterNavigation: React.FC<atoms.FlexProps & {
                    baseStyles?: TagProps.Params;
                }>;
                Comps: {
                    Button: React.FC<ButtonParams>;
                    Title: React.FC<atoms.BoxInput>;
                    Bar: React.FC<atoms.BoxInput>;
                };
                fn: FNs;
            };
            type BaseParams = atoms.BoxInput & {
                topNavigation?: ReactElement;
                sideNavigation?: ReactElement;
                footerNavigation?: ReactElement;
            };
            type ButtonParams = Buttons.ButtonInput & Buttons.Tones.Clear & {
                uri?: string;
                uriGroup?: (string | RegExp) | (string | RegExp)[];
            };
            type FNs = {
                updateCSSProperty: {
                    topNav(): void;
                    footer(): void;
                    reset(): void;
                };
            };
        }
    }
    namespace Tables {
        type Methods = {
            Comps: CompsMethods;
            Normal: (props: Normal.Params) => JSX.Element;
            Data: Data.Methods;
            Drag: (props: Drag.Params) => JSX.Element;
            Spread: () => JSX.Element;
        };
        type CompsMethods = {
            Table: React.FC<TableParams>;
            Head: React.FC<TableHeadParams>;
            Body: React.FC<TableBodyParams>;
            Row: React.FC<TRParams>;
            TH: React.FC<TableCellParams>;
            TD: React.FC<TableCellParams>;
            RightIndicator: Uni.CellParams;
        };
        type DataCompsMethods = {
            Search: any;
            Info: any;
            Paging: any;
        };
        type customTableHTMLAttributes<T> = Omit<React.TableHTMLAttributes<T>, 'border'>;
        type TableParams = TagProps.BasicElement & customTableHTMLAttributes<HTMLTableElement>;
        type TableHeadParams = TagProps.BasicElement & customTableHTMLAttributes<HTMLTableSectionElement>;
        type TableBodyParams = TagProps.BasicElement & customTableHTMLAttributes<HTMLTableSectionElement>;
        type TRParams = TagProps.BasicElement & React.HTMLAttributes<HTMLTableRowElement>;
        type TableCellParams = TagProps.BasicElement & React.ThHTMLAttributes<HTMLTableCellElement>;
        type Types = 'normal' | 'data' | 'drag' | 'spread';
        type Tones = 'border' | 'cellBorder' | 'rowBorder' | 'plain' | 'auto';
        type OnRowClick = {
            (rowIDOrIndex: any, event: React.MouseEvent<HTMLTableRowElement, MouseEvent>): void;
        };
        type StylesCallbackInput = {
            top: boolean;
            bottom: boolean;
            left: boolean;
            right: boolean;
            rowIndex: number;
            colIndex: number;
            isHeader: boolean;
            isBody: boolean;
        };
        namespace Uni {
            type CellParams = TableCellParams & {
                type?: 'th' | 'td';
            };
            type Params = {
                tableID?: string;
                tone?: Tones;
                colLength: number;
                cellStyles?: TagProps.Params;
                cellClassName?: string;
                cellStylesCallback?: {
                    (params: StylesCallbackInput): TagProps.Params;
                };
                className?: string;
            } & TagProps.Params;
        }
        namespace Normal {
            type CellParams = Uni.CellParams;
            type HeadRowParams = CellParams[];
            type BodyRowParams = CellParams[] & {
                rowID?: string | number;
            };
            type Params = Uni.Params & {
                head: HeadRowParams | false;
                rows: BodyRowParams[];
                onRowClick?: OnRowClick;
            };
        }
        namespace Drag {
            type CellParams = Uni.CellParams;
            type HeadRowParams = CellParams[];
            type BodyRowParams = CellParams[] & {
                rowID?: any;
            };
            type Params = Uni.Params & {
                head: HeadRowParams | false;
                rows: BodyRowParams[];
                onOrderChanged: {
                    (orderList: any[]): void;
                };
            };
        }
        namespace Data {
            type CellParams = TableCellParams & {
                type?: 'th' | 'td';
                data: string | number;
                option?: any;
                orderIndex?: string | number;
            };
            type HeadRowParams = CellParams[];
            type BodyRowParams = Array<CellParams> & ArrayObjectParams;
            type ArrayObjectParams = {
                rowID?: any;
                __sys4SearchKey?: string;
                checked?: boolean;
                filtered?: boolean;
                currentPage?: boolean;
            };
            type Params = Uni.Params & {
                tableID?: string;
                head: HeadRowParams;
                rows: BodyRowParams[];
                onRowClick?: OnRowClick;
                eventID?: string;
                checker?: boolean;
                searchKeyword?: string;
                filter?: boolean | boolean[];
                order?: boolean | boolean[];
                defaultOrder?: OrderParams;
                pageRowLength: number;
                noRecords?: ReactElement;
                onOrderChanged?: {
                    (order: OrderParams): void;
                };
            };
            type Methods = {
                (props: Data.Params): JSX.Element;
            } & FNs & Comps;
            type FNs = {
                __memoryID: string;
                useStatus(tableID: string): useStatusOutput;
                getRowData(tableID: string): BodyRowParams[];
                setPageIndex(tableID: string, pageIndex: number): void;
                setRowLength(tableID: string, rowLength: number): void;
                setSearchKeyword(tableID: string, keyword: string): void;
            };
            type Comps = {
                SearchInput: React.FC<{
                    tableID: string;
                }>;
                Info: React.FC<{
                    tableID: string;
                }>;
                Paging: React.FC<{
                    tableID: string;
                }>;
                RowLength: React.FC<{
                    tableID: string;
                    lengthSelect: number[];
                }>;
            };
            type useStatusOutput = {
                tableComponentDidMount: boolean;
                totalRows: number;
                pageRows: number;
                filteredRows: number;
                searchKeyword: string;
                filter: {
                    enabled: boolean;
                    column: boolean[];
                    current: (string[])[];
                };
                order: {
                    enabled: boolean;
                    column: boolean[];
                    current: fn.Tables.Data.OrderParams;
                };
                paging: {
                    rowLength: number;
                    pageLength: number;
                    currentPageIndex: number;
                };
            };
            type FilterColumnsProps = {
                index: number;
                keyword: string;
                enabled: boolean;
            }[];
            type OrderParams = [number, 'ASC' | 'DESC'];
        }
        namespace Spread {
        }
    }
    namespace Input {
        type Methods = {
            Plain: React.FC<TagProps.Params & React.InputHTMLAttributes<HTMLInputElement>>;
            Hidden: (params: Hidden.PlainParams) => JSX.Element;
            Text: Text.Methods;
            TextArea: (params: TextArea.PlainParams) => JSX.Element;
            Contenteditable: (params: Contenteditable.PlainParams) => JSX.Element;
            DigitCharacters: (params: DigitCharacters.PlainParams) => JSX.Element;
            Time: Time.Methods;
            Select: (params: Select.PlainParams) => JSX.Element;
            RichSelect: (params: RichSelect.PlainParams) => JSX.Element;
            Radio: (props: List.PlainParams) => JSX.Element;
            Checkbox: (props: List.PlainParams) => JSX.Element;
            Checker: (params: Checker.PlainParams) => JSX.Element;
            Chips: Chips.Methods;
            Search: (params: Search.PlainParams) => JSX.Element;
            File: Filer.Methods;
            Slider: (params: Slider.PlainParams) => JSX.Element;
            Switch: (params: Switch.PlainParams) => JSX.Element;
            Segmented: Segmented.Types;
            Comps: {
                RequiredSign: React.FC<atoms.SpanProps>;
                RequiredShortSign: React.FC<atoms.SpanProps>;
                OmitSign: React.FC<atoms.SpanProps>;
                LeftIndicator: React.FC<IndicatorParams>;
                RightIndicator: React.FC<IndicatorParams>;
                LeftIcon: React.FC<IndicatorParams>;
                RightIcon: React.FC<IndicatorParams>;
            };
        };
        type WrapperParams = atoms.BoxInput & {
            label?: ReactElement;
            labelStyles?: TagProps.Params;
            required?: boolean | 'plain' | 'omit';
        };
        type UniParams = {
            name?: string;
            form?: string;
            status_id?: string;
            componentID?: string;
            override?: 'force' | 'beforeModified' | 'never';
            required?: boolean;
            enableFormSubmit?: boolean;
            checkValidationAtFirst?: boolean;
            onValidate?: Validation.OnValidate;
            onUpdateValue?: OnUpdateValue;
            onUpdateValidValue?: OnUpdateValue;
        };
        type CoreParams = UniParams & {
            className?: string;
            wrapStyles?: TagProps.Params;
        } & TagProps.Params;
        type OnUpdateValue = {
            (data: {
                value: any;
                componentID: string;
                storeData?: plainObject;
                eventType: Validation.EventType;
            }): void;
        };
        type BoxTone = 'border' | 'cloud' | 'bottomBorder' | 'plain';
        namespace Hidden {
            type PlainParams = React.DOMAttributes<HTMLInputElement> & {
                componentID?: string;
                name?: string;
                form?: string;
                enableFormSubmit?: boolean;
                id?: string;
                value?: string | number | plainObject;
            };
        }
        namespace Text {
            type Methods = {
                Validate(value: any, restrict: Restrict): {
                    ok: boolean;
                    body: ReactElement;
                };
                Normal: (props: OriginParams) => JSX.Element;
                Katakana: (props: OriginParams) => JSX.Element;
                HankakuKatakana: (props: OriginParams) => JSX.Element;
                Number: (props: PlainParams) => JSX.Element;
                DigitNumber: (props: PlainParams) => JSX.Element;
                Tel: (props: PlainParams) => JSX.Element;
                CreditCard: (props: PlainParams) => JSX.Element;
                Email: (props: PlainParams) => JSX.Element;
                Url: (props: PlainParams) => JSX.Element;
                Postal: (props: PlainParams) => JSX.Element;
                Password: (props: PlainParams) => JSX.Element;
                Money: {
                    JPY: (props: PlainParams) => JSX.Element;
                };
            };
            type Restrict = 'text' | 'katakana' | 'hankaku.katakana' | 'number' | 'digitNumber' | 'tel' | 'email' | 'url' | 'fileName' | 'password' | 'postal' | 'creditCard';
            type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                min?: number | null;
                max?: number | null;
                maxLength?: number | null;
                autoComplete?: 'off' | 'none' | string;
                autoCapitalize?: 'off' | 'none' | string;
                clearButton?: boolean;
                value?: string | number;
                placeholder?: string;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                leftIcon?: ReactElement | false;
                rightIcon?: ReactElement | false;
            };
            type OriginParams = PlainParams & {
                restrict?: Restrict;
            };
        }
        namespace TextArea {
            type PlainParams = CoreParams & React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: string | number;
                placeholder?: string;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                leftIcon?: ReactElement | false;
                rightIcon?: ReactElement | false;
            };
        }
        namespace Contenteditable {
            type PlainParams = CoreParams & React.TextareaHTMLAttributes<HTMLDivElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                children?: string;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                leftIcon?: ReactElement | false;
                rightIcon?: ReactElement | false;
            };
        }
        namespace DigitCharacters {
            type PlainParams = CoreParams & React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
                tone?: BoxTone;
                combineInput?: boolean;
                digits: number;
                numericOnly?: boolean;
                tabIndex?: number;
                id?: string;
                value?: string | number;
                listStyles?: TagProps.Params;
            };
        }
        namespace Time {
            type Methods = {
                Clock: (props: PlainParams) => JSX.Element;
                Date: (props: PlainParams) => JSX.Element;
                Week: (props: PlainParams) => JSX.Element;
                Month: (props: PlainParams) => JSX.Element;
                Year: (props: PlainParams) => JSX.Element;
                DateWareki: (props: DateWarekiParams) => JSX.Element;
                Periods: {
                    Date: (props: PeriodParams) => JSX.Element;
                    Month: (props: PeriodParams) => JSX.Element;
                };
                fn: FN;
            };
            type FN = {
                picker: {
                    launch(params: PickerParams & Omit<Tooltips.Params, 'content'>): void;
                    remove(tipsID: string): void;
                };
            };
            type Era = 'clock' | 'year' | 'meiji' | 'taisho' | 'shouwa' | 'heisei' | 'reiwa';
            type Restrict = 'clock' | 'date' | 'week' | 'month' | 'year' | 'dates' | 'months' | 'dateWareki';
            type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: string | [string, string];
                min?: string;
                max?: string;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
            };
            type OriginParams = PlainParams & {
                restrict: Restrict;
                era?: Era;
            };
            type DateWarekiParams = PlainParams & {
                value?: string;
                defaultEra?: 'year' | 'wareki';
            };
            type PeriodParams = Omit<PlainParams, 'value'> & {
                value?: [string, string];
            };
            type RangeProps = {
                type: 'hour' | 'minute' | 'date' | 'month' | 'year' | 'week' | 'dateWareki';
                from: number;
                length: number;
                region?: number;
            };
            type PickerParams = {
                tipsID?: string;
                restrict: Restrict;
                defaultValue: string | string[];
                era?: Era;
                min?: string;
                max?: string;
                onValueUpdate(value: string | [string, string], era: Era): void;
            };
        }
        namespace Select {
            type PlainParams = CoreParams & React.DOMAttributes<HTMLSelectElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: ValueProps;
                options: OptionProps[];
                placeholder?: string;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                leftIcon?: ReactElement | false;
                rightIcon?: ReactElement | false;
                enableUnSelected?: boolean;
                rightIconStyles?: TagProps.Params;
            };
            type ValueProps = string | number | boolean | plainObject | void | null;
            type OptionProps = {
                value: ValueProps;
                label: string;
                displayLabel?: ReactElement;
            };
        }
        namespace RichSelect {
            type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: ValueProps;
                options: OptionProps[];
                placeholder?: string;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                leftIcon?: ReactElement | false;
                rightIcon?: ReactElement | false;
                enableUnSelected?: boolean;
                rightIconStyles?: TagProps.Params;
                cellStyles?: TagProps.Params;
                sheetStyles?: TagProps.Params;
                gravityPoint?: number;
            };
            type ValueProps = string | number | boolean | plainObject | void | null;
            type OptionProps = {
                type?: 'button' | 'label';
                value: ValueProps;
                label: ReactElement;
                selectedLabel?: ReactElement;
            };
        }
        namespace List {
            type ListTone = 'border' | 'cloud' | 'vivid' | 'normal' | 'plain';
            type Methods = {
                Radio: (props: PlainParams) => JSX.Element;
                Checkbox: (props: PlainParams) => JSX.Element;
            };
            type PlainParams = CoreParams & {
                tone?: ListTone;
                icon?: boolean;
                tabIndex?: number;
                id?: string;
                iconType?: 'radio' | 'checkbox';
                minSelect?: number;
                disabled?: boolean;
                value?: any | any[];
                options: OptionParams[];
                hideInput?: boolean;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                cellStyles?: TagProps.Params;
                cellClassName?: string;
                cellCheckedStyles?: TagProps.Params;
                cellCheckedClassName?: string;
                defaultActiveStyling?: boolean;
            };
            type OriginParams = PlainParams & {
                type: 'radio' | 'checkbox' | 'checker';
                tone: ListTone;
            };
            type OptionParams = {
                value: any;
                label: ReactElement;
                disabled?: boolean;
                className?: string;
                checkedStyles?: TagProps.Params;
                checkedClassName?: string;
            } & TagProps.Params;
        }
        namespace Chips {
            type Methods = React.FC<PlainParams> & {
                fn: FNs;
            };
            type PlainParams = CoreParams & {
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: OptionParams[];
                limit?: number;
                selectorGravityPoint?: number;
                defaultOptions?: OptionParams[];
                onDynamicSearch?: onDynamicSearch;
                leftIndicator?: ReactElement | false;
                rightIndicator?: ReactElement | false;
                rightIcon?: ReactElement | false;
                leftIcon?: ReactElement | false;
                SelectedCellComponent?: SelectedCellComponentInput;
                SelectorCellComponent?: SelectorCellComponentInput;
                AddButtonComponent?: AddButtonComponentInput;
            };
            type onDynamicSearch = {
                (k: string): Promise<{
                    options: OptionParams[];
                }>;
            };
            type OptionParams = {
                value: any;
                label: string;
            };
            type SelectedCellComponentInput = React.FC<{
                removeCallback: Function;
                defaultRemoveButton: ReactElement;
                openCallback(): void;
                value: any;
                label: string;
            }>;
            type SelectorCellComponentInput = React.FC<{
                isSelected: boolean;
                isFocused: boolean;
                value: any;
                label: string;
            }>;
            type AddButtonComponentInput = React.FC<{
                selected: OptionParams[];
                openCallback(): void;
            }>;
            type OpenSelectorInput = {
                parent: Jsmin.Args;
                selectorID: string;
                options: OptionParams[];
                selected: OptionParams[];
                bottomContent?: ReactElement;
                gravityPoint?: number;
                limit?: number;
                onDynamicSearch?: {
                    (k: string): Promise<{
                        options: OptionParams[];
                    }>;
                };
                onUpdated(params: {
                    values: any[];
                }): void;
                onClosed(): void;
                SelectorCellComponent?: SelectorCellComponentInput;
            };
            type FNs = {
                openSelector(params: OpenSelectorInput): void;
                closeSelector(selectorID: string): void;
                updateOptions(selectorID: string, options: OptionParams[]): void;
                updateSelected(selectorID: string, selected: OptionParams[]): void;
            };
        }
        namespace Search {
            type PlainParams = Chips.PlainParams;
        }
        namespace Filer {
            type Methods = React.FC<PlainParams> & FNs;
            type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
                tone?: BoxTone;
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: CustomFile[];
                limit?: number;
                fileNameEdit?: boolean;
                systemOnly?: boolean;
                accept?: Accept;
                cellStyles?: TagProps.Params;
                cellClassName?: string;
            };
            type CustomFile = File & {
                id: string;
            };
            type Accept = 'image' | string;
            type FNs = {
                fn: {
                    openDialog(params: {
                        accept?: Accept;
                        multiple?: boolean;
                    }): Promise<File[]>;
                };
            };
        }
        namespace Slider {
            type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
                tabIndex?: number;
                id?: string;
                disabled?: boolean;
                value?: number;
                color?: Color;
                min: number;
                max: number;
                step: number;
                legends?: {
                    enable?: boolean;
                    custom?: LegendsCallback;
                    showAlways?: boolean;
                };
            };
            type Color = TagProps.ThemeColor | 'theme' | 'posi' | 'nega' | 'warn';
            type LegendsCallback = {
                (value: number): ReactElement;
            };
        }
        namespace Switch {
            type PlainParams = UniParams & React.DOMAttributes<HTMLInputElement> & {
                color?: Color;
                id?: string;
                tabIndex?: number;
                appearance?: 'material' | 'applely';
                disabled?: boolean;
                value?: boolean;
                icon?: ReactElement;
            };
            type Color = TagProps.ThemeColor | 'theme' | 'posi' | 'nega' | 'warn';
        }
        namespace Segmented {
            type Tones = 'Border' | 'ThemeBorder' | 'BottomLine' | 'Cloud' | 'ThemeCloud' | 'WhiteCloud';
            type Types = {
                Auto: (params: Params) => JSX.Element;
                Normal: (params: Params) => JSX.Element;
                Cloud: (params: Params) => JSX.Element;
                Cloud2: (params: Params) => JSX.Element;
                Cloud3: (params: Params) => JSX.Element;
                Border: (params: Params) => JSX.Element;
                Border2: (params: Params) => JSX.Element;
                BottomLine: (params: Params) => JSX.Element;
            };
            type Params = List.PlainParams;
            type ListParams = List.OptionParams[];
        }
        namespace Checker {
            type PlainParams = CoreParams & {
                label: ReactElement;
                id?: string;
                tabIndex?: number;
                disabled?: boolean;
                value?: boolean;
                cellStyles?: TagProps.Params;
                cellClassName?: string;
                cellCheckedStyles?: TagProps.Params;
                cellCheckedClassName?: string;
            };
        }
        namespace Status {
            type Plain = {
                componentID: string;
                dataValue: any;
                eventType: Validation.EventType;
                eventID: string;
            };
            type Text = Plain & {
                formatValue: any;
                prevValue: any;
                caretFrom: number;
                caretTo: number;
            };
            type DigitCharacters = Plain & {
                formatValue: any;
            };
            type Time = Plain & {
                formatValue: any;
                ranges: Time.RangeProps[];
            };
            type Slider = Plain & {
                min: number;
                max: number;
                step: number;
            };
        }
        namespace Validation {
            type EventType = 'init' | 'update' | 'override' | 'refresh';
            type Notice = {
                type: 'valid' | 'invalid' | 'warn';
                label: ReactElement;
            };
            type Result = {
                ok: boolean;
                notice: Notice[];
            };
            type SystemCheck = {
                (props: {
                    value: any;
                    params: any;
                }): Result;
            };
            type OnValidate = {
                (state: {
                    eventType: EventType;
                    value: any;
                    props: plainObject;
                }): Promise<Result>;
            };
        }
        type IndicatorParams = TagProps.Params & {
            tone?: BoxTone;
            className?: string;
            children: ReactElement;
        };
    }
    namespace Buttons {
        type Methods = Seed & {};
        type Seeds = 'Button' | 'Label' | 'Anchor';
        type Tones = 'Plain' | 'Link' | 'Normal' | 'Border' | 'Prime' | 'Sub' | 'Clear' | 'FillToBorder' | 'BorderToFill';
        type Sizes = 'XS' | 'S' | 'R' | 'L';
        type Colors = 'theme' | 'posi' | 'nega' | 'warn' | 'cloud' | 'trans' | 'white' | 'plain';
        type Seed = {
            Button: Tone<ButtonInput>;
            Label: Tone<LabelInput>;
            Anchor: Tone<AnchorInput>;
        };
        type Tone<T> = {
            Plain: React.FC<T>;
            Link: React.FC<T>;
            Normal: Size<T>;
            Border: Size<T>;
            Prime: Size<T & Tones.Prime>;
            Sub: Size<T & Tones.Sub>;
            Clear: Size<T & Tones.Clear>;
            FillToBorder: Size<T & Tones.FillToBorder>;
            BorderToFill: Size<T & Tones.BorderToFill>;
        };
        type Size<T> = {
            XS: React.FC<T>;
            S: React.FC<T>;
            R: React.FC<T>;
            L: React.FC<T>;
        };
        namespace Tones {
            type Plain = {};
            type Link = {};
            type Normal = {};
            type Border = {};
            type Prime = {
                color?: Colors | TagProps.ThemeColor;
            };
            type Sub = {
                color?: Colors | 'layer';
            };
            type Clear = {
                color?: Colors | 'layer';
            };
            type FillToBorder = {
                color?: Colors;
            };
            type BorderToFill = {
                color?: Colors;
            };
        }
        type UniParams = TagProps.BasicElement & {
            tabIndex?: number;
            children?: ReactElement;
            'aria-label'?: string;
            isLocked?: boolean;
            isActive?: boolean;
            isActiveStyles?: TagProps.Params;
            isActiveClassName?: string;
        };
        type delegateClickEventProps = 'auxEnter' | 'enter' | 'space';
        type ButtonInput = UniParams & {
            submitOption?: {
                formName: string;
                acceptInvalidForm?: boolean;
                submitDelegationKey?: delegateClickEventProps | delegateClickEventProps[];
                callback(form: plainObject, ok: boolean): void;
            };
        } & React.ButtonHTMLAttributes<HTMLButtonElement>;
        type LabelInput = UniParams & {
            htmlFor?: string;
        } & React.LabelHTMLAttributes<HTMLLabelElement>;
        type AnchorInput = UniParams & {
            href?: string;
            newTab?: boolean;
            sync?: boolean;
            download?: any;
            shiftQueryParams?: boolean;
        } & React.ButtonHTMLAttributes<HTMLAnchorElement>;
    }
    namespace Sheet {
        type Methods = {
            open(params: Params): void;
            refresh(params: Params, open: boolean): void;
            resize(params: {
                sheetID: string;
                size: SizeParams;
            }): void;
            reposition(sheetID: string): void;
            close(key: string, eventType?: 'Escape' | 'pageTransit', force?: boolean): void;
            closeGroup(keyGroup: string): void;
            closeAll(pageTransit?: boolean): void;
            Comps: {
                Body: React.FC<atoms.BoxInput>;
            };
        };
        type Params = NormalParams | EdgeParams | CustomParams | ImageParams | Bottom.Params;
        type UniParams = {
            sheetID?: string;
            sheetGroups?: string | string[];
            backgroundEffect?: boolean;
            content: ReactElement | {
                (): JSX.Element;
            };
            overwrap?: boolean;
            close_option?: CloseOptions;
            hold_state?: boolean;
            openAfter?(): void;
            closeAfter?(): void;
        } & TagProps.BasicElement;
        type SizeParams = 'S' | 'R' | 'L' | '2L' | '3L' | 'MAX';
        type CloseOptions = {
            pageTransit?: boolean;
            escapeKeyDown?: boolean;
            aroundClick?: boolean;
            elementBlur?: Jsmin.Args;
        };
        type Sheet = 'normal.topLeft' | 'normal.topCenter' | 'normal.topRight' | 'normal.middleLeft' | 'normal.middleCenter' | 'normal.middleRight' | 'normal.bottomLeft' | 'normal.bottomCenter' | 'normal.bottomRight' | 'drawer.left' | 'drawer.right' | 'drawer.bottom' | 'custom' | 'image';
        type NormalParams = UniParams & {
            type: Sheet;
            size?: SizeParams;
        };
        type EdgeParams = UniParams & {
            type: Sheet;
            size?: SizeParams;
        };
        type CustomParams = UniParams & {
            type: 'custom';
            parent: Jsmin.Args;
            gravityPoint?: number;
        };
        type ImageParams = Omit<UniParams, 'content'> & {
            type: 'image';
            src: string | string[];
        };
        namespace Bottom {
            type Sizes = 'S' | 'R' | 'L';
            type Params = UniParams & {
                type: 'drawer.bottom';
                size: Sizes;
                sizeChanged?(size: Sizes): void;
                baseStyles?: TagProps.Params;
                close_option?: CloseOptions & {
                    swipeDown?: boolean;
                };
            };
        }
    }
    namespace Tooltips {
        type Methods = {
            __memoryID: string;
            open(params: Params): void;
            close(tipsID: string): void;
            closeALL(): void;
            Comps: {
                Body: React.FC<atoms.BoxInput>;
            };
        };
        type Params = {
            tipsID?: string;
            tipsGroups?: string | string[];
            parent: Jsmin.Args;
            gravityPoint?: number;
            close_option?: Sheet.CloseOptions;
            hold_state?: boolean;
            content: ReactElement | {
                (): JSX.Element;
            };
            openAfter?(): void;
            closeAfter?(): void;
        } & TagProps.BasicElement;
    }
    namespace SnackBar {
        type Methods = {
            __memoryID: string;
            add(props: AddParams): SnackBar.Methods;
            remove(snackID: string): SnackBar.Methods;
            __launch(): void;
        };
        type AddParams = Omit<atoms.BoxInput, 'children'> & {
            children?: ReactElement | {
                (): JSX.Element;
            };
            customChildren?: {
                (params: {
                    close(): void;
                }): JSX.Element;
            };
            snackID?: string;
            secondsToClose?: number;
        };
    }
    namespace Loader {
        type Methods = Color & FNs;
        type Color = {
            Theme: Size<CompInput>;
            Posi: Size<CompInput>;
            Nega: Size<CompInput>;
            Warn: Size<CompInput>;
            White: Size<CompInput>;
            Cloud: Size<CompInput>;
        };
        type Size<T> = {
            S: React.FC<T>;
            R: React.FC<T>;
            L: React.FC<T>;
            XL: React.FC<T>;
            MAX: React.FC<T>;
        };
        type Sizes = 'S' | 'R' | 'L' | 'XL' | 'MAX';
        type Colors = 'theme' | 'posi' | 'nega' | 'warn' | 'white' | 'cloud';
        type CompInput = TagProps.Params & {
            showInitial?: boolean;
            loaderID?: string;
        };
        type FNs = {
            __memoryID: string;
            __launch(): void;
            fn: {
                stopALL(): void;
                top: {
                    active(): void;
                    stop(): void;
                };
                corner: {
                    active(): void;
                    stop(): void;
                };
                mini: {
                    active(loaderID?: string): void;
                    stop(loaderID?: string): void;
                    stopALL(): void;
                };
            };
        };
    }
    namespace Cropper {
        type Use = 'square' | 'wallpaper.horizontal' | 'wallpaper.vertical';
        type Params = {
            use: Use;
            develops: DevelopParams[];
            onProcessFinished: {
                (files: Input.Filer.CustomFile[]): void;
            };
        };
        type DevelopParams = {
            size: 'S' | 'R' | 'L';
            maxSize?: number;
        };
        type Methods = {
            open(params: Params): void;
        };
    }
    namespace Effects {
        type FadeUniParams = atoms.BoxInput & {
            animationTime?: number;
            animationDelay?: number;
        };
        type Methods = {
            FadeIn: React.FC<FadeUniParams>;
            FadeUp: React.FC<FadeUniParams>;
        };
    }
    type Methods = {
        Table: fn.Tables.Methods;
        Layout: fn.Layout.Methods;
        Buttons: fn.Buttons.Methods;
        Input: fn.Input.Methods;
        Sheet: fn.Sheet.Methods;
        SnackBar: fn.SnackBar.Methods;
        Loader: fn.Loader.Methods;
        Tooltips: fn.Tooltips.Methods;
        Effects: fn.Effects.Methods;
        Cropper: fn.Cropper.Methods;
    };
}