amotify 0.1.6 → 0.1.8

package/dist/@declaration/amotify.d.ts

@@ -1,1353 +0,0 @@
-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;
-    };
-}