amotify 0.0.2 → 0.0.4

package/src/@types/fn.tsx

@@ -0,0 +1,1210 @@
+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>
+          // NumberCount: FNC<{
+          //   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
+      }
+    }
+  }
+}