amotify 0.0.4 → 0.0.5

package/dist/src/@types/fn.d.ts

@@ -1,1040 +0,0 @@
-/// <reference types="react" />
-export {};
-declare global {
-    namespace amotify {
-        namespace fn {
-            namespace Layout {
-                type Methods = {
-                    PageViewController: FNC<PageViewController.Params>;
-                    TabBar: FNC<TabBar.Params>;
-                    Plate: FNC<Plate.Params>;
-                    SwipeView: FNC<SwipeView.Params>;
-                    PageRouter: FNC<PageRouter.RouterProps>;
-                    PageNotFound: FNC<{}>;
-                    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;
-                        };
-                    } & amotifyBasicElement;
-                }
-                namespace Plate {
-                    type Params = {
-                        size?: 'XS' | 'S' | 'R' | 'L' | 'XL' | 'MAX';
-                    } & atoms.BoxInput;
-                }
-                namespace SwipeView {
-                    type Params = amotifyBasicElement & {
-                        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: FNC<RootViewController.BaseParams>;
-                        TopNavigation: FNC<amotify.atoms.FlexProps>;
-                        SideNavigation: FNC<amotify.atoms.FlexProps & {
-                            baseStyles?: amotifyUniStyleParams;
-                        }>;
-                        FooterNavigation: FNC<amotify.atoms.FlexProps & {
-                            baseStyles?: amotifyUniStyleParams;
-                        }>;
-                        Comps: {
-                            Button: FNC<ButtonParams>;
-                            Title: FNC<atoms.BoxInput>;
-                            Bar: FNC<atoms.BoxInput>;
-                        };
-                    };
-                    type BaseParams = atoms.BoxInput & {
-                        topNavigation?: ReactElement;
-                        sideNavigation?: ReactElement;
-                        footerNavigation?: ReactElement;
-                    };
-                    type ButtonParams = Buttons.ButtonInput & Buttons.Tones.Clear & {
-                        uri?: string;
-                        uriGroup?: (string | RegExp) | (string | RegExp)[];
-                    };
-                }
-            }
-            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: FNC<TableParams>;
-                    Head: FNC<TableHeadParams>;
-                    Body: FNC<TableBodyParams>;
-                    Row: FNC<TRParams>;
-                    TH: FNC<TableCellParams>;
-                    TD: FNC<TableCellParams>;
-                    RightIndicator: Uni.CellParams;
-                };
-                type DataCompsMethods = {
-                    Search: any;
-                    Info: any;
-                    Paging: any;
-                };
-                type TableParams = amotifyBasicElement & React.TableHTMLAttributes<HTMLTableElement>;
-                type TableHeadParams = amotifyBasicElement & React.TableHTMLAttributes<HTMLTableSectionElement>;
-                type TableBodyParams = amotifyBasicElement & React.TableHTMLAttributes<HTMLTableSectionElement>;
-                type TRParams = amotifyBasicElement & React.HTMLAttributes<HTMLTableRowElement>;
-                type TableCellParams = amotifyBasicElement & 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?: amotifyUniStyleParams;
-                        cellClassName?: string;
-                        cellStylesCallback?: {
-                            (params: StylesCallbackInput): amotifyUniStyleParams;
-                        };
-                        className?: string;
-                    } & amotifyUniStyleParams;
-                }
-                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;
-                    };
-                    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: FNC<{
-                            tableID: string;
-                        }>;
-                        Info: FNC<{
-                            tableID: string;
-                        }>;
-                        Paging: FNC<{
-                            tableID: string;
-                        }>;
-                        RowLength: FNC<{
-                            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: amotify.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: FNC<amotifyUniStyleParams & React.InputHTMLAttributes<HTMLInputElement>>;
-                    Hidden: (params: Hidden.PlainParams) => JSX.Element;
-                    Text: Text.Methods;
-                    TextArea: (params: TextArea.PlainParams) => JSX.Element;
-                    DigitCharacters: (params: DigitCharacters.PlainParams) => JSX.Element;
-                    Time: Time.Methods;
-                    Select: (params: Select.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: FNC<amotify.atoms.SpanProps>;
-                        OmitSign: FNC<amotify.atoms.SpanProps>;
-                        LeftIndicator: FNC<IndicatorParams>;
-                        RightIndicator: FNC<IndicatorParams>;
-                        LeftIcon: FNC<IndicatorParams>;
-                        RightIcon: FNC<IndicatorParams>;
-                    };
-                };
-                type WrapperParams = atoms.BoxInput & {
-                    label?: ReactElement;
-                    labelStyles?: amotifyUniStyleParams;
-                    required?: boolean | 'plain' | 'omit';
-                };
-                type UniParams = {
-                    name?: string;
-                    form?: string;
-                    statusID?: string;
-                    componentID?: string;
-                    override?: 'force' | 'beforeModified' | 'never';
-                    required?: boolean;
-                    checkValidationAtFirst?: boolean;
-                    onValidate?: Validation.OnValidate;
-                    onUpdateValue?: OnUpdateValue;
-                    onUpdateValidValue?: OnUpdateValue;
-                };
-                type CoreParams = UniParams & {
-                    className?: string;
-                    wrapStyles?: amotifyUniStyleParams;
-                } & amotifyUniStyleParams;
-                type OnUpdateValue = {
-                    (data: {
-                        value: any;
-                        componentID: string;
-                        storeData?: plainObject;
-                        eventType: Validation.EventType;
-                    }): void;
-                };
-                type BoxToneTypes = 'border' | 'cloud' | 'bottomBorder' | 'plain';
-                namespace Hidden {
-                    type PlainParams = React.DOMAttributes<HTMLInputElement> & {
-                        componentID?: string;
-                        name?: string;
-                        form?: string;
-                        id?: string;
-                        value?: string | number | plainObject;
-                    };
-                }
-                namespace Text {
-                    type Methods = {
-                        Validate(value: any, restrict: RestrictTypes): {
-                            ok: boolean;
-                            body: ReactElement;
-                        };
-                        Normal: (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 RestrictTypes = 'text' | 'number' | 'digitNumber' | 'tel' | 'email' | 'url' | 'fileName' | 'password' | 'postal' | 'creditCard';
-                    type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
-                        tone?: BoxToneTypes;
-                        tabIndex?: number;
-                        id?: string;
-                        disabled?: boolean;
-                        min?: number | null;
-                        max?: number | null;
-                        maxLength?: number | null;
-                        enableFormSubmit?: boolean;
-                        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?: RestrictTypes;
-                    };
-                }
-                namespace TextArea {
-                    type PlainParams = CoreParams & React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
-                        tone?: BoxToneTypes;
-                        tabIndex?: number;
-                        id?: string;
-                        disabled?: boolean;
-                        enableFormSubmit?: boolean;
-                        value?: string | number;
-                        placeholder?: 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?: BoxToneTypes;
-                        combineInput?: boolean;
-                        digits: number;
-                        numericOnly?: boolean;
-                        tabIndex?: number;
-                        id?: string;
-                        enableFormSubmit?: boolean;
-                        value?: string | number;
-                        listStyles?: amotifyUniStyleParams;
-                    };
-                }
-                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: FNTypes;
-                    };
-                    type FNTypes = {
-                        picker: {
-                            launch(params: PickerParams & Omit<Tooltips.Params, 'content'>): void;
-                            remove(tipsID: string): void;
-                        };
-                    };
-                    type EraTypes = 'clock' | 'year' | 'meiji' | 'taisho' | 'shouwa' | 'heisei' | 'reiwa';
-                    type RestrictTypes = 'clock' | 'date' | 'week' | 'month' | 'year' | 'dates' | 'months' | 'dateWareki';
-                    type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
-                        tone?: BoxToneTypes;
-                        tabIndex?: number;
-                        id?: string;
-                        disabled?: boolean;
-                        enableFormSubmit?: boolean;
-                        value?: string | [string, string];
-                        min?: string;
-                        max?: string;
-                        leftIndicator?: ReactElement | false;
-                        rightIndicator?: ReactElement | false;
-                    };
-                    type OriginParams = PlainParams & {
-                        restrict: RestrictTypes;
-                        era?: EraTypes;
-                    };
-                    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: RestrictTypes;
-                        defaultValue: string | string[];
-                        min?: string;
-                        max?: string;
-                        onValueUpdate(value: string | [string, string]): void;
-                    };
-                }
-                namespace Select {
-                    type PlainParams = CoreParams & React.DOMAttributes<HTMLSelectElement> & {
-                        tone?: BoxToneTypes;
-                        tabIndex?: number;
-                        id?: string;
-                        disabled?: boolean;
-                        enableFormSubmit?: boolean;
-                        value?: ValueProps;
-                        options: OptionProps[];
-                        placeholder?: string;
-                        leftIndicator?: ReactElement | false;
-                        rightIndicator?: ReactElement | false;
-                        enableUnSelected?: boolean;
-                        rightIconStyles?: amotifyUniStyleParams;
-                        leftIcon?: ReactElement | false;
-                        rightIcon?: ReactElement | false;
-                    };
-                    type ValueProps = string | number | boolean | plainObject | void | null;
-                    type OptionProps = {
-                        value: ValueProps;
-                        label: string;
-                        displayLabel?: ReactElement;
-                    };
-                }
-                namespace List {
-                    type ListToneTypes = 'border' | 'cloud' | 'vivid' | 'normal' | 'plain';
-                    type Methods = {
-                        Radio: (props: PlainParams) => JSX.Element;
-                        Checkbox: (props: PlainParams) => JSX.Element;
-                    };
-                    type PlainParams = CoreParams & {
-                        tone?: ListToneTypes;
-                        icon?: boolean;
-                        tabIndex?: number;
-                        id?: string;
-                        iconType?: 'radio' | 'checkbox';
-                        minSelect?: number;
-                        enableFormSubmit?: boolean;
-                        disabled?: boolean;
-                        value?: any | any[];
-                        options: OptionParams[];
-                        hideInput?: boolean;
-                        leftIndicator?: ReactElement | false;
-                        rightIndicator?: ReactElement | false;
-                        cellStyles?: amotifyUniStyleParams;
-                        cellClassName?: string;
-                        cellCheckedStyles?: amotifyUniStyleParams;
-                        cellCheckedClassName?: string;
-                        defaultActiveStyling?: boolean;
-                    };
-                    type OriginParams = PlainParams & {
-                        type: 'radio' | 'checkbox' | 'checker';
-                        tone: ListToneTypes;
-                    };
-                    type OptionParams = {
-                        value: any;
-                        label: ReactElement;
-                        disabled?: boolean;
-                        className?: string;
-                        checkedStyles?: amotifyUniStyleParams;
-                        checkedClassName?: string;
-                    } & amotifyUniStyleParams;
-                }
-                namespace Chips {
-                    type Methods = FNC<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 = FNC<{
-                        removeCallback: Function;
-                        defaultRemoveButton: ReactElement;
-                        openCallback(): void;
-                        value: any;
-                        label: string;
-                    }>;
-                    type SelectorCellComponentInput = FNC<{
-                        isSelected: boolean;
-                        isFocused: boolean;
-                        value: any;
-                        label: string;
-                    }>;
-                    type AddButtonComponentInput = FNC<{
-                        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 = FNC<PlainParams> & FNs;
-                    type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
-                        tone?: BoxToneTypes;
-                        tabIndex?: number;
-                        id?: string;
-                        disabled?: boolean;
-                        value?: CustomFile[];
-                        limit?: number;
-                        fileNameEdit?: boolean;
-                        systemOnly?: boolean;
-                        accept?: AcceptTypes;
-                        cellStyles?: amotifyUniStyleParams;
-                        cellClassName?: string;
-                    };
-                    type CustomFile = File & {
-                        id: string;
-                    };
-                    type AcceptTypes = 'image' | string;
-                    type FNs = {
-                        fn: {
-                            openDialog(params: {
-                                accept?: AcceptTypes;
-                                multiple?: boolean;
-                            }): Promise<File[]>;
-                        };
-                    };
-                }
-                namespace Slider {
-                    type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
-                        tabIndex?: number;
-                        id?: string;
-                        disabled?: boolean;
-                        value?: number;
-                        color?: ColorTypes;
-                        min: number;
-                        max: number;
-                        step: number;
-                        legends?: {
-                            enable?: boolean;
-                            custom?: LegendsCallback;
-                            showAlways?: boolean;
-                        };
-                        enableFormSubmit?: boolean;
-                    };
-                    type ColorTypes = amotify.ThemeColorTypes | 'theme' | 'posi' | 'nega' | 'warn';
-                    type LegendsCallback = {
-                        (value: number): ReactElement;
-                    };
-                }
-                namespace Switch {
-                    type PlainParams = UniParams & React.DOMAttributes<HTMLInputElement> & {
-                        color?: ColorTypes;
-                        id?: string;
-                        tabIndex?: number;
-                        appearance?: 'material' | 'applely';
-                        disabled?: boolean;
-                        value?: boolean;
-                        icon?: string;
-                        enableFormSubmit?: boolean;
-                    };
-                    type ColorTypes = amotify.ThemeColorTypes | '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;
-                        enableFormSubmit?: boolean;
-                        cellStyles?: amotifyUniStyleParams;
-                        cellClassName?: string;
-                        cellCheckedStyles?: amotifyUniStyleParams;
-                        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 NoticeTypes = {
-                        type: 'valid' | 'invalid' | 'warn';
-                        label: ReactElement;
-                    };
-                    type Result = {
-                        ok: boolean;
-                        notice: NoticeTypes[];
-                    };
-                    type SystemCheck = {
-                        (props: {
-                            value: any;
-                            params: any;
-                        }): Result;
-                    };
-                    type OnValidate = {
-                        (state: {
-                            eventType: EventType;
-                            value: any;
-                            props: plainObject;
-                        }): Promise<Result>;
-                    };
-                }
-                type IndicatorParams = amotifyUniStyleParams & {
-                    tone?: BoxToneTypes;
-                    className?: string;
-                    children: ReactElement;
-                };
-            }
-            namespace Buttons {
-                type Methods = SeedTypes & {};
-                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 SeedTypes = {
-                    Button: ToneTypes<ButtonInput>;
-                    Label: ToneTypes<LabelInput>;
-                    Anchor: ToneTypes<AnchorInput>;
-                };
-                type ToneTypes<T> = {
-                    Plain: FNC<T>;
-                    Link: FNC<T>;
-                    Normal: SizeTypes<T>;
-                    Border: SizeTypes<T>;
-                    Prime: SizeTypes<T & Tones.Prime>;
-                    Sub: SizeTypes<T & Tones.Sub>;
-                    Clear: SizeTypes<T & Tones.Clear>;
-                    FillToBorder: SizeTypes<T & Tones.FillToBorder>;
-                    BorderToFill: SizeTypes<T & Tones.BorderToFill>;
-                };
-                type SizeTypes<T> = {
-                    XS: FNC<T>;
-                    S: FNC<T>;
-                    R: FNC<T>;
-                    L: FNC<T>;
-                };
-                namespace Tones {
-                    type Plain = {};
-                    type Link = {};
-                    type Normal = {};
-                    type Border = {};
-                    type Prime = {
-                        color?: Colors | amotify.ThemeColorTypes;
-                    };
-                    type Sub = {
-                        color?: Colors | 'layer';
-                    };
-                    type Clear = {
-                        color?: Colors | 'layer';
-                    };
-                    type FillToBorder = {
-                        color?: Colors;
-                    };
-                    type BorderToFill = {
-                        color?: Colors;
-                    };
-                }
-                type UniParams = amotifyBasicElement & {
-                    tabIndex?: number;
-                    children?: ReactElement;
-                    'aria-label'?: string;
-                    isLocked?: boolean;
-                    isActive?: boolean;
-                    isActiveStyles?: amotifyUniStyleParams;
-                    isActiveClassName?: string;
-                    activeStyles?: amotifyUniStyleParams;
-                    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'): void;
-                    closeGroup(keyGroup: string): void;
-                    closeAll(pageTransit?: boolean): void;
-                    Comps: {
-                        Body: FNC<atoms.BoxInput>;
-                    };
-                };
-                type Params = NormalParams | EdgeParams | CustomParams | ImageParams | Bottom.Params;
-                type UniParams = {
-                    sheetID?: string;
-                    sheetGroups?: string | string[];
-                    content: ReactElement | {
-                        (): JSX.Element;
-                    };
-                    overwrap?: boolean;
-                    closeOption?: CloseOptions;
-                    holdState?: boolean;
-                    openAfter?(): void;
-                    closeAfter?(): void;
-                } & amotifyBasicElement;
-                type SizeParams = 'S' | 'R' | 'L' | '2L' | '3L' | 'MAX';
-                type CloseOptions = {
-                    pageTransit?: boolean;
-                    escapeKeyDown?: boolean;
-                    aroundClick?: boolean;
-                    elementBlur?: Jsmin.Args;
-                };
-                type SheetTypes = '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: SheetTypes;
-                    size?: SizeParams;
-                };
-                type EdgeParams = UniParams & {
-                    type: SheetTypes;
-                    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?: amotifyUniStyleParams;
-                        closeOption?: CloseOptions & {
-                            swipeDown?: boolean;
-                        };
-                    };
-                }
-            }
-            namespace Tooltips {
-                type Methods = {
-                    __memoryID: string;
-                    open(params: Params): void;
-                    close(tipsID: string): void;
-                    closeALL(): void;
-                    Comps: {
-                        Body: FNC<atoms.BoxInput>;
-                    };
-                };
-                type Params = {
-                    tipsID?: string;
-                    tipsGroups?: string | string[];
-                    parent: Jsmin.Args;
-                    gravityPoint?: number;
-                    closeOption?: Sheet.CloseOptions;
-                    content: ReactElement | {
-                        (): JSX.Element;
-                    };
-                    holdState?: boolean;
-                    openAfter?(): void;
-                    closeAfter?(): void;
-                } & amotifyBasicElement;
-            }
-            namespace SnackBar {
-                type Methods = {
-                    __memoryID: string;
-                    add(props: AddParams): SnackBar.Methods;
-                    remove(snackID: string): SnackBar.Methods;
-                };
-                type AddParams = Omit<atoms.BoxInput, 'children'> & {
-                    children?: ReactElement | {
-                        (): JSX.Element;
-                    };
-                    customChildren?: {
-                        (params: {
-                            close(): void;
-                        }): JSX.Element;
-                    };
-                    snackID?: string;
-                    secondsToClose?: number;
-                };
-            }
-            namespace Loader {
-                type Methods = ColorTypes & FNs;
-                type ColorTypes = {
-                    Theme: SizeTypes<CompInput>;
-                    Posi: SizeTypes<CompInput>;
-                    Nega: SizeTypes<CompInput>;
-                    Warn: SizeTypes<CompInput>;
-                    White: SizeTypes<CompInput>;
-                    Cloud: SizeTypes<CompInput>;
-                };
-                type SizeTypes<T> = {
-                    S: FNC<T>;
-                    R: FNC<T>;
-                    L: FNC<T>;
-                    XL: FNC<T>;
-                    MAX: FNC<T>;
-                };
-                type Sizes = 'S' | 'R' | 'L' | 'XL' | 'MAX';
-                type Colors = 'theme' | 'posi' | 'nega' | 'warn' | 'white' | 'cloud';
-                type CompInput = amotifyUniStyleParams & {
-                    showInitial?: boolean;
-                    loaderID?: string;
-                };
-                type FNs = {
-                    __memoryID: string;
-                    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 Params = {
-                    use: 'profile' | 'header';
-                    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: FNC<FadeUniParams>;
-                    FadeUp: FNC<FadeUniParams>;
-                };
-            }
-            type Methods = {
-                Table: amotify.fn.Tables.Methods;
-                Layout: amotify.fn.Layout.Methods;
-                Buttons: amotify.fn.Buttons.Methods;
-                Input: amotify.fn.Input.Methods;
-                Sheet: amotify.fn.Sheet.Methods;
-                SnackBar: amotify.fn.SnackBar.Methods;
-                Loader: amotify.fn.Loader.Methods;
-                Tooltips: amotify.fn.Tooltips.Methods;
-                Effects: amotify.fn.Effects.Methods;
-                Cropper: amotify.fn.Cropper.Methods;
-            };
-        }
-    }
-}