amotify 0.0.64 → 0.0.66

package/@types/fn.tsx

@@ -1,1280 +0,0 @@
-export default {}
-declare global {
-  namespace amotify {
-    namespace fn {
-      namespace Layout {
-        type Methods = {
-          PageViewController: React.FC<PageViewController.Params>
-          TabBar: React.FC<TabBar.Params>
-          Plate: React.FC<Plate.Params>
-          SwipeView: React.FC<SwipeView.Params>
-
-          PageRouter: React.FC<PageRouter.RouterProps>
-
-          PageNotFound: React.FC<{}>
-
-          RootViewController: RootViewController.Methods
-        }
-
-        namespace PageViewController {
-          type Params = {
-            viewIndex: number
-            views: ReactElement[]
-            wrapper?: {
-              ( view: ReactElement ): ReactElement
-            }
-          }
-        }
-
-        namespace TabBar {
-          type Params = {
-            tabIndex: number
-            tabs: ReactElement[]
-            onTabChange?: {
-              ( index: number ): void
-            }
-
-            componentDidMount?: {
-              (): void
-            }
-          } & 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 = React.FC<PlainParams> & {
-          //   fn: FNs
-          // }
-
-          type Methods = {
-            Base: React.FC<RootViewController.BaseParams>
-            TopNavigation: React.FC<amotify.atoms.FlexProps>
-            SideNavigation: React.FC<amotify.atoms.FlexProps & {
-              baseStyles?: amotifyUniStyleParams
-            }>
-            FooterNavigation: React.FC<amotify.atoms.FlexProps & {
-              baseStyles?: amotifyUniStyleParams
-            }>
-            Comps: {
-              Button: React.FC<ButtonParams>
-              Title: React.FC<atoms.BoxInput>
-              Bar: React.FC<atoms.BoxInput>
-            }
-            fn: FNs
-          }
-
-          type BaseParams = atoms.BoxInput & {
-            topNavigation?: ReactElement
-            sideNavigation?: ReactElement
-            footerNavigation?: ReactElement
-          }
-
-          type ButtonParams = Buttons.ButtonInput & Buttons.Tones.Clear & {
-            uri?: string
-            uriGroup?: ( string | RegExp ) | ( string | RegExp )[]
-          }
-
-          type FNs = {
-            updateCSSProperty: {
-              topNav(): void
-              footer(): void
-              reset(): void
-            }
-          }
-        }
-      }
-      namespace Tables {
-        type Methods = {
-          Comps: CompsMethods
-
-          Normal: ( props: Normal.Params ) => JSX.Element
-          Data: Data.Methods
-          Drag: ( props: Drag.Params ) => JSX.Element
-          Spread: () => JSX.Element
-        }
-
-        type CompsMethods = {
-          Table: React.FC<TableParams>
-          Head: React.FC<TableHeadParams>
-          Body: React.FC<TableBodyParams>
-          Row: React.FC<TRParams>
-
-          TH: React.FC<TableCellParams>
-          TD: React.FC<TableCellParams>
-          RightIndicator: Uni.CellParams
-        }
-        type DataCompsMethods = {
-          Search: any
-          Info: any
-          Paging: any
-        }
-
-        type customTableHTMLAttributes<T> = Omit<React.TableHTMLAttributes<T>,'border'>
-        type TableParams = amotifyBasicElement & customTableHTMLAttributes<HTMLTableElement>
-        type TableHeadParams = amotifyBasicElement & customTableHTMLAttributes<HTMLTableSectionElement>
-        type TableBodyParams = amotifyBasicElement & customTableHTMLAttributes<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
-
-            onOrderChanged?: {
-              ( order: OrderParams ): void
-            }
-          }
-
-          type Methods = {
-            ( props: Data.Params ): JSX.Element
-          } & FNs & Comps
-          type FNs = {
-            __memoryID: string
-            useStatus( tableID: string ): useStatusOutput
-            getRowData( tableID: string ): BodyRowParams[]
-            setPageIndex( tableID: string,pageIndex: number ): void
-            setRowLength( tableID: string,rowLength: number ): void
-            setSearchKeyword( tableID: string,keyword: string ): void
-          }
-          type Comps = {
-            SearchInput: React.FC<{ tableID: string }>
-            Info: React.FC<{ tableID: string }>
-            Paging: React.FC<{ tableID: string }>
-            RowLength: React.FC<{
-              tableID: string
-              lengthSelect: number[]
-            }>
-          }
-
-          type useStatusOutput = {
-            tableComponentDidMount: boolean
-            totalRows: number
-            pageRows: number
-            filteredRows: number
-            searchKeyword: string
-            filter: {
-              enabled: boolean
-              column: boolean[]
-              current: ( string[] )[]
-            }
-            order: {
-              enabled: boolean
-              column: boolean[]
-              current: 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: React.FC<amotifyUniStyleParams & React.InputHTMLAttributes<HTMLInputElement>>
-          Hidden: ( params: Hidden.PlainParams ) => JSX.Element
-          Text: Text.Methods
-          TextArea: ( params: TextArea.PlainParams ) => JSX.Element
-          Contenteditable: ( params: Contenteditable.PlainParams ) => JSX.Element
-          DigitCharacters: ( params: DigitCharacters.PlainParams ) => JSX.Element
-          Time: Time.Methods
-          Select: ( params: Select.PlainParams ) => JSX.Element
-          RichSelect: ( params: RichSelect.PlainParams ) => JSX.Element
-
-          Radio: ( props: List.PlainParams ) => JSX.Element
-          Checkbox: ( props: List.PlainParams ) => JSX.Element
-          Checker: ( params: Checker.PlainParams ) => JSX.Element
-
-          Chips: Chips.Methods
-          Search: ( params: Search.PlainParams ) => JSX.Element
-          File: Filer.Methods
-          Slider: ( params: Slider.PlainParams ) => JSX.Element
-          Switch: ( params: Switch.PlainParams ) => JSX.Element
-
-          Segmented: Segmented.Types
-
-          Comps: {
-            RequiredSign: React.FC<amotify.atoms.SpanProps>
-            RequiredShortSign: React.FC<amotify.atoms.SpanProps>
-            OmitSign: React.FC<amotify.atoms.SpanProps>
-            LeftIndicator: React.FC<IndicatorParams>
-            RightIndicator: React.FC<IndicatorParams>
-            LeftIcon: React.FC<IndicatorParams>
-            RightIcon: React.FC<IndicatorParams>
-          }
-        }
-
-        type WrapperParams = atoms.BoxInput & {
-          label?: ReactElement
-          labelStyles?: amotifyUniStyleParams
-          required?: boolean | 'plain' | 'omit'
-        }
-
-        type UniParams = {
-          name?: string
-          form?: string
-
-          status_id?: string
-          componentID?: string
-
-          override?: 'force' | 'beforeModified' | 'never'
-
-          required?: boolean
-
-          enableFormSubmit?: boolean
-
-          checkValidationAtFirst?: boolean
-          onValidate?: Validation.OnValidate
-          onUpdateValue?: OnUpdateValue
-          onUpdateValidValue?: OnUpdateValue
-        }
-        type CoreParams = UniParams & {
-          className?: string
-          wrapStyles?: 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
-
-            enableFormSubmit?: boolean
-
-            id?: string
-            value?: string | number | plainObject
-          }
-        }
-        namespace Text {
-          type Methods = {
-            Validate( value: any,restrict: RestrictTypes ): {
-              ok: boolean
-              body: ReactElement
-            }
-            Normal: ( props: OriginParams ) => JSX.Element
-            Katakana: ( props: OriginParams ) => JSX.Element
-            HankakuKatakana: ( props: OriginParams ) => JSX.Element
-            Number: ( props: PlainParams ) => JSX.Element
-            DigitNumber: ( props: PlainParams ) => JSX.Element
-            Tel: ( props: PlainParams ) => JSX.Element
-            CreditCard: ( props: PlainParams ) => JSX.Element
-            Email: ( props: PlainParams ) => JSX.Element
-            Url: ( props: PlainParams ) => JSX.Element
-            Postal: ( props: PlainParams ) => JSX.Element
-            Password: ( props: PlainParams ) => JSX.Element
-            Money: {
-              JPY: ( props: PlainParams ) => JSX.Element
-            }
-          }
-
-          type RestrictTypes = 'text' | 'katakana' | 'hankaku.katakana' | '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
-
-            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
-
-
-            value?: string | number
-
-            placeholder?: string
-
-            leftIndicator?: ReactElement | false
-            rightIndicator?: ReactElement | false
-            leftIcon?: ReactElement | false
-            rightIcon?: ReactElement | false
-          }
-        }
-        namespace Contenteditable {
-          type PlainParams = CoreParams & React.TextareaHTMLAttributes<HTMLDivElement> & {
-            tone?: BoxToneTypes
-
-            tabIndex?: number
-            id?: string
-
-            children?: string
-
-            leftIndicator?: ReactElement | false
-            rightIndicator?: ReactElement | false
-            leftIcon?: ReactElement | false
-            rightIcon?: ReactElement | false
-          }
-        }
-        namespace DigitCharacters {
-          type PlainParams = CoreParams & React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>,HTMLInputElement> & {
-            tone?: BoxToneTypes
-
-            combineInput?: boolean
-            digits: number
-            numericOnly?: boolean
-
-            tabIndex?: number
-            id?: string
-
-
-            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
-
-
-            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[]
-            era?: EraTypes
-            min?: string
-            max?: string
-            onValueUpdate( value: string | [ string,string ],era: EraTypes ): void
-          }
-        }
-        namespace Select {
-          type PlainParams = CoreParams & React.DOMAttributes<HTMLSelectElement> & {
-            tone?: BoxToneTypes
-
-            tabIndex?: number
-
-            id?: string
-
-            disabled?: boolean
-
-
-            value?: ValueProps
-            options: OptionProps[]
-
-            placeholder?: string
-
-            leftIndicator?: ReactElement | false
-            rightIndicator?: ReactElement | false
-            leftIcon?: ReactElement | false
-            rightIcon?: ReactElement | false
-
-            enableUnSelected?: boolean
-
-            rightIconStyles?: amotifyUniStyleParams
-
-          }
-
-          type ValueProps = string | number | boolean | plainObject | void | null
-
-          type OptionProps = {
-            value: ValueProps
-            label: string
-            displayLabel?: ReactElement
-          }
-        }
-        namespace RichSelect {
-          type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
-            tone?: BoxToneTypes
-
-            tabIndex?: number
-
-            id?: string
-
-            disabled?: boolean
-
-            value?: ValueProps
-            options: OptionProps[]
-
-            placeholder?: string
-
-            leftIndicator?: ReactElement | false
-            rightIndicator?: ReactElement | false
-            leftIcon?: ReactElement | false
-            rightIcon?: ReactElement | false
-
-            enableUnSelected?: boolean
-
-            rightIconStyles?: amotifyUniStyleParams
-
-            cellStyles?: amotifyUniStyleParams
-            sheetStyles?: amotifyUniStyleParams
-
-            gravityPoint?: number
-          }
-
-          type ValueProps = string | number | boolean | plainObject | void | null
-
-          type OptionProps = {
-            type?: 'button' | 'label'
-            value: ValueProps
-            label: ReactElement
-            selectedLabel?: 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
-
-
-            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 = React.FC<PlainParams> & {
-            fn: FNs
-          }
-
-          type PlainParams = CoreParams & {
-            tabIndex?: number
-
-            id?: string
-
-            disabled?: boolean
-
-            value?: OptionParams[]
-            limit?: number
-
-            selectorGravityPoint?: number
-
-            defaultOptions?: OptionParams[]
-            onDynamicSearch?: onDynamicSearch
-
-            leftIndicator?: ReactElement | false
-            rightIndicator?: ReactElement | false
-            rightIcon?: ReactElement | false
-            leftIcon?: ReactElement | false
-
-            SelectedCellComponent?: SelectedCellComponentInput
-            SelectorCellComponent?: SelectorCellComponentInput
-            AddButtonComponent?: AddButtonComponentInput
-          }
-          type onDynamicSearch = {
-            ( k: string ): Promise<{
-              options: OptionParams[]
-            }>
-          }
-          type OptionParams = {
-            value: any
-            label: string
-          }
-          type SelectedCellComponentInput = React.FC<{
-            removeCallback: Function
-            defaultRemoveButton: ReactElement
-            openCallback(): void
-            value: any
-            label: string
-          }>
-          type SelectorCellComponentInput = React.FC<{
-            isSelected: boolean
-            isFocused: boolean
-            value: any
-            label: string
-          }>
-          type AddButtonComponentInput = React.FC<{
-            selected: OptionParams[]
-            openCallback(): void
-          }>
-
-          type OpenSelectorInput = {
-            parent: Jsmin.Args
-            selectorID: string
-            options: OptionParams[]
-            selected: OptionParams[]
-            bottomContent?: ReactElement
-            gravityPoint?: number
-            limit?: number
-            onDynamicSearch?: {
-              ( k: string ): Promise<{
-                options: OptionParams[]
-              }>
-            }
-            onUpdated( params: {
-              values: any[]
-            } ): void
-            onClosed(): void
-            SelectorCellComponent?: SelectorCellComponentInput
-          }
-
-          type FNs = {
-            openSelector( params: OpenSelectorInput ): void
-            closeSelector( selectorID: string ): void
-            updateOptions( selectorID: string,options: OptionParams[] ): void
-            updateSelected( selectorID: string,selected: OptionParams[] ): void
-          }
-        }
-        namespace Search {
-          type PlainParams = Chips.PlainParams
-        }
-        namespace Filer {
-          type Methods = React.FC<PlainParams> & FNs
-
-          type PlainParams = CoreParams & React.DOMAttributes<HTMLInputElement> & {
-            tone?: 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
-            }
-
-          }
-
-          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?: ReactElement
-          }
-
-          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
-
-
-            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: React.FC<T>
-          Link: React.FC<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: React.FC<T>
-          S: React.FC<T>
-          R: React.FC<T>
-          L: React.FC<T>
-        }
-
-        namespace Tones {
-          type Plain = {}
-          type Link = {}
-          type Normal = {}
-          type Border = {}
-          type Prime = { color?: Colors | 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',force?: boolean ): void
-          closeGroup( keyGroup: string ): void
-          closeAll( pageTransit?: boolean ): void
-          Comps: {
-            Body: React.FC<atoms.BoxInput>
-          }
-        }
-
-        type Params = NormalParams | EdgeParams | CustomParams | ImageParams | Bottom.Params
-
-        type UniParams = {
-          sheetID?: string
-          sheetGroups?: string | string[]
-          backgroundEffect?: boolean
-          content: ReactElement | {
-            (): JSX.Element
-          }
-          overwrap?: boolean
-          close_option?: CloseOptions
-          hold_state?: boolean
-
-          openAfter?(): void
-          closeAfter?(): void
-        } & 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
-            close_option?: CloseOptions & {
-              swipeDown?: boolean
-            }
-          }
-        }
-      }
-      namespace Tooltips {
-        type Methods = {
-          __memoryID: string
-          open( params: Params ): void
-          close( tipsID: string ): void
-          closeALL(): void
-          Comps: {
-            Body: React.FC<atoms.BoxInput>
-          }
-        }
-
-        type Params = {
-          tipsID?: string
-          tipsGroups?: string | string[]
-          parent: Jsmin.Args
-          gravityPoint?: number
-          close_option?: Sheet.CloseOptions
-          hold_state?: boolean
-          content: ReactElement | {
-            (): JSX.Element
-          }
-          openAfter?(): void
-          closeAfter?(): void
-        } & 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: React.FC<T>
-          R: React.FC<T>
-          L: React.FC<T>
-          XL: React.FC<T>
-          MAX: React.FC<T>
-        }
-
-        type Sizes = 'S' | 'R' | 'L' | 'XL' | 'MAX'
-        type Colors = 'theme' | 'posi' | 'nega' | 'warn' | 'white' | 'cloud'
-
-        type CompInput = 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 UseTypes = 'square' | 'wallpaper.horizontal' | 'wallpaper.vertical'
-        type Params = {
-          use: UseTypes
-          develops: DevelopParams[]
-          onProcessFinished: {
-            ( files: Input.Filer.CustomFile[] ): void
-          }
-        }
-
-        type DevelopParams = {
-          size: 'S' | 'R' | 'L'
-          maxSize?: number
-        }
-        type Methods = {
-          open( params: Params ): void
-        }
-      }
-      namespace Effects {
-        type FadeUniParams = atoms.BoxInput & {
-          animationTime?: number
-          animationDelay?: number
-        }
-        type Methods = {
-          FadeIn: React.FC<FadeUniParams>
-          FadeUp: React.FC<FadeUniParams>
-          // NumberCount: React.FC<{
-          //   from: number
-          //   to: number
-          //   ms:number
-          //   cb?: {
-          //     ( value: number ): ReactElement
-          //   }
-          // }>
-        }
-      }
-
-      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
-      }
-    }
-  }
-}