amotify 0.0.65 → 0.0.67

package/dist/src/@declations/amotify.d.ts

@@ -0,0 +1,1358 @@
+import { Jsmin } from 'jsmin-front';
+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 { Styles } from './styles';
+export declare namespace config {
+    interface Methods {
+        version: string;
+        launchID: string;
+        appRootID: string;
+        appRoot: HTMLElement;
+        themeColor: Styles.ThemeColor;
+        darkMode: Styles.DarkMode;
+        roundness: Styles.Roundness;
+        device: {
+            deviceIs: Device;
+            browserIs: Browser;
+            isBreakpoint(): boolean;
+            isPhonepoint(): boolean;
+            isSystemDarkmode(): boolean;
+            isPhone: boolean;
+            isTouchDevice: boolean;
+            isIOS: boolean;
+        };
+        update: {
+            themeColor(value: Styles.ThemeColor): void;
+            darkMode(value: Styles.DarkMode): void;
+            roundness(value: Styles.Roundness): void;
+        };
+        variables: {
+            darkmodeColors: {
+                light: string;
+                dark: string;
+                dim: string;
+                auto(): string;
+            };
+            themeColors: {
+                [key in Styles.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?: Styles.Roundness;
+            themeColor?: Styles.ThemeColor;
+            darkMode?: Styles.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 = Styles.BasicElement & {
+        children?: ReactElement;
+    } & React.HTMLAttributes<HTMLDivElement>;
+    type SpanProps = Styles.BasicElement & {
+        children?: ReactElement;
+    } & React.HTMLAttributes<HTMLSpanElement>;
+    type ParagraphProps = Styles.BasicElement & {
+        children?: ReactElement;
+    } & React.HTMLAttributes<HTMLParagraphElement>;
+    type FlexProps = Styles.BasicElement & {
+        children?: ReactElement;
+    } & React.HTMLAttributes<HTMLDivElement>;
+    type GridProps = Styles.BasicElement & {
+        children: ReactElement;
+        onClick?: {
+            (event: React.MouseEvent<HTMLDivElement, MouseEvent>): void;
+        };
+    } & React.HTMLAttributes<HTMLDivElement>;
+    namespace FAI {
+        type Method = React.FC<FAIParams> & Shortcuts;
+        type FAIParams = Styles.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 = Styles.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 = Styles.BasicElement & {
+            size?: 'S' | 'R' | 'L' | '2L' | '3L';
+            color?: 'normal' | 'white';
+            children?: ReactElement | React.FC<any>;
+        };
+        type DefaultLogo = Styles.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<Styles.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 = Styles.BasicElement & {
+            rowStyles?: Styles.Params;
+            rows: RowsParams[];
+        };
+        type RowsParams = {
+            children: ReactElement;
+        } & Styles.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 = {
+        PlayGround: React.FC<{}>;
+    };
+}
+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;
+                };
+            } & Styles.BasicElement;
+        }
+        namespace Plate {
+            type Params = {
+                size?: 'XS' | 'S' | 'R' | 'L' | 'XL' | 'MAX';
+            } & atoms.BoxInput;
+        }
+        namespace SwipeView {
+            type Params = Styles.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?: Styles.Params;
+                }>;
+                FooterNavigation: React.FC<atoms.FlexProps & {
+                    baseStyles?: Styles.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 = Styles.BasicElement & customTableHTMLAttributes<HTMLTableElement>;
+        type TableHeadParams = Styles.BasicElement & customTableHTMLAttributes<HTMLTableSectionElement>;
+        type TableBodyParams = Styles.BasicElement & customTableHTMLAttributes<HTMLTableSectionElement>;
+        type TRParams = Styles.BasicElement & React.HTMLAttributes<HTMLTableRowElement>;
+        type TableCellParams = Styles.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?: Styles.Params;
+                cellClassName?: string;
+                cellStylesCallback?: {
+                    (params: StylesCallbackInput): Styles.Params;
+                };
+                className?: string;
+            } & Styles.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<Styles.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?: Styles.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?: Styles.Params;
+        } & Styles.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?: Styles.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?: Styles.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?: Styles.Params;
+                cellStyles?: Styles.Params;
+                sheetStyles?: Styles.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?: Styles.Params;
+                cellClassName?: string;
+                cellCheckedStyles?: Styles.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?: Styles.Params;
+                checkedClassName?: string;
+            } & Styles.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?: Styles.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 = Styles.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 = Styles.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?: Styles.Params;
+                cellClassName?: string;
+                cellCheckedStyles?: Styles.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 = Styles.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 | Styles.ThemeColor;
+            };
+            type Sub = {
+                color?: Colors | 'layer';
+            };
+            type Clear = {
+                color?: Colors | 'layer';
+            };
+            type FillToBorder = {
+                color?: Colors;
+            };
+            type BorderToFill = {
+                color?: Colors;
+            };
+        }
+        type UniParams = Styles.BasicElement & {
+            tabIndex?: number;
+            children?: ReactElement;
+            'aria-label'?: string;
+            isLocked?: boolean;
+            isActive?: boolean;
+            isActiveStyles?: Styles.Params;
+            isActiveClassName?: string;
+            activeStyles?: Styles.Params;
+            activeClassName?: 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;
+        } & Styles.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?: Styles.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;
+        } & Styles.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 = Styles.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;
+    };
+}