amotify 0.0.2 → 0.0.4

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

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