amotify 0.0.2 → 0.0.4

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

@@ -0,0 +1,62 @@
+/// <reference types="react" />
+declare global {
+    type ReactElement = React.ReactNode | React.ReactNode[];
+    type React = typeof React;
+    type FNC<P> = React.FC<P>;
+    interface plainObject {
+        [index: string]: any;
+    }
+    namespace amotify {
+        type ToneTypes = 'default' | 'flat' | 'sharp';
+        type DarkModeTypes = 'light' | 'auto' | 'dark' | 'dim';
+        type ThemeColorTypes = 'comun' | 'leaf' | 'heart' | 'droplet' | 'brick' | 'flower' | 'lip' | 'wine' | 'theater' | 'bat' | 'poizon' | 'eggplant' | 'ufo' | 'alien' | 'tombstone' | 'ninja' | 'moon' | 'rain' | 'unicorn' | 'axe' | 'gem' | 'soap' | 'drizzle' | 'building' | 'fish' | 'icicles' | 'water' | 'tree1' | 'tree2' | 'tree3' | 'battery' | 'seedle' | 'greenTea' | 'oak' | 'salad' | 'cloudy' | 'lemon' | 'angel' | 'parasol' | 'pizza' | 'thunder' | 'latte' | 'island' | 'shovel' | 'coffee' | 'carrot' | 'cactus' | 'volcano' | 'choco' | 'industry' | 'gun' | 'galaxy' | 'line' | 'twitter' | 'amazon' | 'facebook' | 'android' | 'slackBlue' | 'slackGreen' | 'slackRed' | 'slackYellow' | 'slackBase' | 'googleBlue' | 'googleGreen' | 'googleYellow' | 'googleRed';
+        type RoundnessTypes = 0 | 1 | 2 | 3 | 4 | 5;
+        namespace config {
+            type Methods = {
+                version: string;
+                tone: amotify.ToneTypes;
+                themeColor: amotify.ThemeColorTypes;
+                darkMode: amotify.DarkModeTypes;
+                roundness: amotify.RoundnessTypes;
+                device: {
+                    isWhat: 'Windows' | 'Android' | 'iPhone' | 'iPad' | 'macOSX' | 'undefined';
+                    isBreakpoint(): boolean;
+                    isPhonepoint(): boolean;
+                    isSystemDarkmode(): boolean;
+                    isPhone: boolean;
+                    isTouchDevice: boolean;
+                    isIOS: boolean;
+                };
+                update: {
+                    tone(value: amotify.ToneTypes): void;
+                    themeColor(value: amotify.ThemeColorTypes): void;
+                    darkMode(value: amotify.DarkModeTypes): void;
+                    roundness(value: amotify.RoundnessTypes): void;
+                };
+                readExtraCDN(url: string): Promise<boolean>;
+            };
+        }
+    }
+    interface amotify {
+        config: amotify.config.Methods;
+        glob: amotify.glob.Methods;
+        atoms: amotify.atoms.Methods;
+        mols: amotify.mols.Methods;
+        orgs: amotify.orgs.Methods;
+        temps: amotify.temps.Methods;
+        fn: amotify.fn.Methods;
+    }
+    var amotify: amotify;
+    namespace _WebSocket {
+        interface Methods {
+            emit(path: string, data: any): _WebSocket.Methods;
+            on(path: string, data: {
+                (data: any): void;
+            }): _WebSocket.Methods;
+        }
+    }
+    var io: {
+        (url: string): _WebSocket.Methods;
+    };
+}
+export {};

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

@@ -0,0 +1,134 @@
+/// <reference types="react" />
+export {};
+declare global {
+    interface JsminExtension {
+        fetch: {
+            get: JsminExtension.Fetch.CoreParams;
+            post: JsminExtension.Fetch.CoreParams;
+            put: JsminExtension.Fetch.CoreParams;
+            options: JsminExtension.Fetch.CoreParams;
+            waitList: string[];
+            defaultHeaders: plainObject;
+            defaultResultCallback?: {
+                (params: Jsmin.Fetch.Output): void;
+            };
+        };
+    }
+    namespace JsminExtension {
+        namespace Fetch {
+            type CoreParams = {
+                (params: JsminExtension.Fetch.Input, callback?: JsminExtension.Fetch.callback): Promise<Jsmin.Fetch.Output>;
+            };
+            type Input = {
+                key: string;
+                topLoader?: boolean;
+                cornerLoader?: boolean;
+                trafficControl?: number;
+                preventMultiRequest?: boolean;
+            } & Omit<Jsmin.Fetch.Input, 'method'>;
+            type callback = {
+                (result: Jsmin.Fetch.Output): void;
+            };
+        }
+    }
+    interface JsminExtension {
+        spreadSheet: {
+            readFromFile(file: amotify.fn.Input.Filer.CustomFile): Promise<JsminExtension.SpreadSheet.Method>;
+            readFromJson(v: JsminExtension.SpreadSheet.JsonTypes): Promise<JsminExtension.SpreadSheet.Method>;
+        };
+    }
+    namespace JsminExtension {
+        namespace SpreadSheet {
+            interface Instance {
+                fn: Method;
+                prototype: Method;
+                (v: any, a: string): any;
+            }
+            interface Method {
+                getWorkbook(): any;
+                updateFileName(fileName: string): void;
+                updateMerges(merges: MergeTypes[][]): void;
+                updateStyles(styles: StyleTypes[][]): void;
+                toJson(): {
+                    fileName: string;
+                    sheets: {
+                        sheetName: string;
+                        rows: any[];
+                    }[];
+                };
+                export(type?: 'xlsx' | 'csv'): void;
+            }
+            type JsonTypes = {
+                fileName: string;
+                sheets: SheetParams[];
+            };
+            type SheetParams = {
+                sheetName: string;
+                rows: RowParams[];
+                headers?: HeaderParams[];
+                merges?: MergeTypes[];
+                styles?: StyleTypes[];
+            };
+            type HeaderParams = {
+                key: string;
+                value: string;
+            };
+            type RowParams = {
+                [key: string]: string | number;
+            };
+            type MergeTypes = [string, string] | [null, null];
+            type StyleTypes = {
+                type: 'cell' | 'row' | 'column';
+                target: string | number | (string | number)[];
+                values: {
+                    [key: string]: any;
+                };
+            };
+        }
+    }
+    interface JsminExtension {
+        formCollect(form: string): Promise<{
+            valid: boolean;
+            data: plainObject;
+        }>;
+        NoticeHttpStatus(params: {
+            status: number;
+            statusText: string;
+            label: ReactElement;
+        } & amotify.fn.SnackBar.AddParams): void;
+        copyToClipboard(data: any): Promise<{
+            ok: boolean;
+            body: any;
+        }>;
+        getCurrentLocation: {
+            (): Promise<JsminExtension.getCurrentLocationOutput>;
+        };
+        CDNReader: {
+            (url: string): void;
+        };
+        ImageLoader: {
+            (dataUrl: string, img?: HTMLImageElement): Promise<HTMLImageElement>;
+        };
+        isJSXElement(v: any): v is JSX.Element;
+    }
+    namespace JsminExtension {
+        type getCurrentLocationOutput = {
+            ok: false;
+            status: number;
+            body: {
+                reason: any;
+            };
+        } | {
+            ok: true;
+            status: 200;
+            body: {
+                lat: number;
+                lng: number;
+            };
+        };
+    }
+    type base64ToBlobTypeProps = 'image/png' | 'image/jpeg' | string;
+    interface String {
+        zen2hanNumber(): string;
+    }
+}

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

@@ -0,0 +1,2 @@
+declare module "*.scss";
+declare module "react-dom";

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

@@ -0,0 +1,145 @@
+/// <reference types="react" />
+export {};
+declare global {
+    type amotifyBasicElement = amotify.UniStyles.BasicTagParams & amotifyUniStyleParams;
+    type amotifyUniStyleParams = amotify.UniStyles.Params & {
+        freeCSS?: React.CSSProperties;
+        UnderBreakPointStyles?: amotify.UniStyles.Params;
+        hoverStyles?: amotify.UniStyles.Params;
+        focusStyles?: amotify.UniStyles.Params;
+        activeStyles?: amotify.UniStyles.Params;
+        ssEffectsOnActive?: amotify.UniStyles.Others.EffectsOnActiveTypes | amotify.UniStyles.Others.EffectsOnActiveTypes[] | false;
+        ssPushable?: boolean;
+        ssLastChildLossBorder?: 'bottom' | 'right' | false;
+    };
+    namespace amotify {
+        namespace UniStyles {
+            type BasicTagParams = {
+                className?: string;
+                id?: string;
+                componentID?: string;
+            };
+            type Params = Pargins.Params & Fonts.Params & Borders.Params & FlexGrids.Params & Sizes.Params & StyleSets.Params & {
+                backgroundColor?: Others.BackgroundColorParams;
+                gradients?: {
+                    deg: number;
+                    colors: string[];
+                };
+                boxShadow?: 0 | 1 | 2 | 3 | 4 | -1 | -2 | -3 | 'none' | 'borderBox';
+                display?: 'block' | 'none' | 'flex' | 'grid' | 'inlineBlock' | 'inlineFlex';
+                gap?: Others.gapParams;
+                overflow?: Others.overflowParams;
+                position?: 'relative' | 'absolute' | 'fixed' | 'sticky' | 'static';
+                top?: Others.TRBLParams | 'topBase' | 'topNavigationHeight';
+                right?: Others.TRBLParams;
+                bottom?: Others.TRBLParams;
+                left?: Others.TRBLParams;
+                opacity?: 'trans' | 'low' | 'middle' | 'high' | 'most';
+                transition?: 'none' | 'short' | 'middle' | 'long';
+            };
+            namespace Pargins {
+                type Params = {
+                    margin?: GroupParams;
+                    marginTop?: UnitParams;
+                    marginRight?: UnitParams;
+                    marginBottom?: UnitParams;
+                    marginLeft?: UnitParams;
+                    padding?: GroupParams;
+                    paddingTop?: UnitParams;
+                    paddingRight?: UnitParams;
+                    paddingBottom?: UnitParams;
+                    paddingLeft?: UnitParams;
+                };
+                type UnitParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 1.5 | 2 | 2.5 | 3 | 4 | 'auto' | 'safeAreaTop' | 'safeAreaBottom';
+                type GroupParams = UnitParams | [UnitParams, UnitParams] | [UnitParams, UnitParams, UnitParams, UnitParams];
+            }
+            namespace Borders {
+                type Params = {
+                    border?: BorderParams;
+                    borderTop?: BorderParams;
+                    borderRight?: BorderParams;
+                    borderBottom?: BorderParams;
+                    borderLeft?: BorderParams;
+                    borderWidth?: WidthParams;
+                    borderColor?: ColorParams;
+                    borderStyle?: StyleParams;
+                    borderRadius?: RadiusParams;
+                    borderTopLeftRadius?: RadiusParams;
+                    borderTopRightRadius?: RadiusParams;
+                    borderBottomLeftRadius?: RadiusParams;
+                    borderBottomRightRadius?: RadiusParams;
+                };
+                type BorderParams = boolean | '0.trans' | '1.thin' | '2.normal' | '3.strong' | 'unset';
+                type WidthParams = 0 | 1 | 2 | 3 | 4;
+                type ColorParams = '0.trans' | '1.thin' | '2.normal' | '3.strong' | 'theme' | 'posi' | 'nega' | 'warn' | 'white';
+                type StyleParams = 'solid' | 'dashed' | 'double' | 'dotted';
+                type RadiusParams = 0 | '1/3' | '2/3' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 'sphere' | 'inherit' | '1.tone.primary' | '2.tone.secondary' | '3.tone.tertiary';
+            }
+            namespace FlexGrids {
+                type Params = {
+                    flexSizing?: 'none' | 'auto' | 0;
+                    flexWrap?: boolean;
+                    flexCenter?: boolean;
+                    flexType?: TypeParams;
+                    flexChilds?: 'even' | 'auto' | 'none' | 'unset';
+                    flexGrid?: GridParams;
+                    flexNewLine?: boolean;
+                    verticalAlign?: VerticalAlignParams;
+                    horizontalAlign?: HorizontalAlignParams;
+                    gridCenter?: boolean;
+                    gridCols?: GridColsParams;
+                };
+                type TypeParams = 'row' | 'row-r' | 'col' | 'col-r';
+                type VerticalAlignParams = 'center' | 'top' | 'bottom' | 'baseline' | 'unset';
+                type HorizontalAlignParams = 'center' | 'left' | 'right' | 'between' | 'around' | 'even' | 'unset';
+                type GridParams = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'unset';
+                type GridColsParams = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+            }
+            namespace Fonts {
+                type Params = {
+                    fontColor?: ColorParams;
+                    fontSize?: SizeParams;
+                    fontWeight?: WeightParams;
+                    isBoldFont?: boolean;
+                    isRounded?: boolean;
+                    textAlign?: 'left' | 'center' | 'right';
+                };
+                type WeightParams = '1.lighter' | '2.normal' | '3.bold';
+                type ColorParams = Others.UniColors | '1.clear' | '2.normal' | '3.blur' | '4.thin' | '5.translucent' | '6.clear' | 'mono' | 'monoSecond' | 'logo';
+                type SizeParams = '0.xs' | '1.mini' | '2.normal' | '3.paragraph' | '4.thirdTitle' | '5.subTitle' | '6.title' | '7.landing' | '8.xl' | 'inherit';
+            }
+            namespace Sizes {
+                type Params = {
+                    maxHeight?: 0 | 1 | 'viewHeight' | 'topNavigationHeight' | 'sideNavigationHeight' | 'contentHeight' | 'unset';
+                    minHeight?: 0 | 1 | 'viewHeight' | 'topNavigationHeight' | 'sideNavigationHeight' | 'contentHeight' | 'unset';
+                    minWidth?: 0 | 1 | 'unset';
+                    maxWidth?: 0 | 1 | 'unset';
+                    unitWidth?: SizeParams;
+                    unitHeight?: SizeParams;
+                    width?: 0 | 1 | 'viewWidth' | 'auto';
+                    height?: 0 | 1 | 'viewHeight' | 'topNavigationHeight' | 'sideNavigationHeight' | 'contentHeight' | 'auto';
+                };
+                type SizeParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 6 | 8 | 12 | 'unset';
+            }
+            namespace StyleSets {
+                type Params = {
+                    ssCardBox?: boolean | 'border' | 'layer' | 'cloud' | 'shadow';
+                    ssSphere?: Sizes.SizeParams;
+                    ssSquare?: Sizes.SizeParams;
+                    ssAbsoluteCovered?: boolean;
+                    ssTextEllipsis?: boolean;
+                };
+            }
+            namespace Others {
+                type gapUnitParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 1.5 | 2 | 2.5 | 3 | 4;
+                type gapParams = gapUnitParams | [gapUnitParams, gapUnitParams];
+                type overflowUnitParams = 'auto' | 'hidden' | 'scroll' | 'visible' | 'unset';
+                type overflowParams = overflowUnitParams | [overflowUnitParams, overflowUnitParams];
+                type UniColors = 'inherit' | 'theme' | 'posi' | 'nega' | 'warn' | 'white' | 'black' | amotify.ThemeColorTypes;
+                type BackgroundColorParams = UniColors | '1.layer.base' | '2.layer.cloud' | '3.layer.canvas' | '4.layer.darken' | '5.layer.darker' | '6.layer.darkest' | 'cloud' | 'lcOpFew' | 'lcOpLow' | 'lcOpMiddle' | 'lcOpHigh' | 'tcOpFew' | 'tcOpLow' | 'tcOpMiddle' | 'tcOpHigh' | 'tcLighten' | 'tcLighter' | 'tcLightest' | 'tcDarken' | 'tcDarker' | 'tcDarkest' | 'negaOpLow' | 'negaOpMiddle' | 'posiOpLow' | 'posiOpMiddle' | 'trans' | 'dark' | 'monoPrime' | 'monoSecond' | 'none';
+                type TRBLParams = 0 | '1/12' | '1/6' | '1/4' | '1/3' | '1/2' | '2/3' | '3/4' | 1 | 2 | 3 | 4 | '50%' | '100%';
+                type EffectsOnActiveTypes = 'ripple.white' | 'ripple.cloud' | 'ripple.theme' | 'none' | 'expand' | 'shrink' | 'pudding' | 'fade';
+            }
+        }
+    }
+}

package/dist/src/Atoms/@export.d.ts

@@ -0,0 +1,4 @@
+import { Box, Span, Img, Flex, FlexBr, Grid, Paragraph, Placeholder } from './Various/parts';
+import { FAIcon } from './FAIcon/parts';
+import { Logo } from './Logo/parts';
+export { Flex, FlexBr, FAIcon, Placeholder, Grid, Logo, Box, Span, Paragraph, Img };

package/dist/src/Atoms/FAIcon/parts.d.ts

@@ -0,0 +1,2 @@
+declare const FAIcon: amotify.atoms.FAIcon.Method;
+export { FAIcon };

package/dist/src/Atoms/Logo/parts.d.ts

@@ -0,0 +1 @@
+export declare const Logo: amotify.atoms.Logos.Methods;

package/dist/src/Atoms/Various/parts.d.ts

@@ -0,0 +1,9 @@
+export declare const Box: FNC<amotify.atoms.BoxInput>;
+export declare const Span: FNC<amotify.atoms.SpanProps>;
+export declare const Placeholder: FNC<amotify.atoms.PlaceholderParams>;
+declare let Img: amotify.atoms.Image.Methods;
+export { Img };
+export declare const Flex: FNC<amotify.atoms.FlexProps>;
+export declare const FlexBr: FNC<amotifyUniStyleParams>;
+export declare const Grid: FNC<amotify.atoms.GridProps>;
+export declare const Paragraph: FNC<amotify.atoms.ParagraphProps>;

package/dist/src/Functions/@export.d.ts

@@ -0,0 +1,12 @@
+import { Effects } from './Effects/_';
+import { Buttons } from './Button/_';
+import { Input } from './Input/_';
+import { Inputs } from './Inputs/_';
+import { Layout } from './Layout/_';
+import { Table } from './Table/_';
+import { Sheet } from './Sheet/parts';
+import { SnackBar } from './SnackBar/parts';
+import { Loader } from './Loader/parts';
+import { Tooltips } from './Tooltips/parts';
+import { Cropper } from './Cropper/parts';
+export { Buttons, Input, Inputs, Table, Layout, Sheet, SnackBar, Loader, Tooltips, Effects, Cropper, };

package/dist/src/Functions/Button/_.d.ts

@@ -0,0 +1 @@
+export declare const Buttons: amotify.fn.Buttons.Methods;

package/dist/src/Functions/Cropper/parts.d.ts

@@ -0,0 +1 @@
+export declare const Cropper: amotify.fn.Cropper.Methods;

package/dist/src/Functions/Effects/Fade.d.ts

@@ -0,0 +1 @@
+export declare const FadeEffects: amotify.fn.Effects.Methods;

package/dist/src/Functions/Effects/Ripple.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/Functions/Effects/_.d.ts

@@ -0,0 +1,3 @@
+import './Ripple';
+declare const Effects: amotify.fn.Effects.Methods;
+export { Effects };

package/dist/src/Functions/Input/Chips/Selector.d.ts

@@ -0,0 +1 @@
+export declare const ChipsInputFNs: amotify.fn.Input.Chips.FNs;

package/dist/src/Functions/Input/Chips/_.d.ts

@@ -0,0 +1,2 @@
+declare const ChipsInput: amotify.fn.Input.Chips.Methods;
+export { ChipsInput };

package/dist/src/Functions/Input/DigitCharacters.d.ts

@@ -0,0 +1 @@
+export declare const DigitCharactersInput: FNC<amotify.fn.Input.DigitCharacters.PlainParams>;

package/dist/src/Functions/Input/File/_.d.ts

@@ -0,0 +1,2 @@
+declare const FileInput: amotify.fn.Input.Filer.Methods;
+export { FileInput };

package/dist/src/Functions/Input/Hidden.d.ts

@@ -0,0 +1 @@
+export declare const HiddenInput: FNC<amotify.fn.Input.Hidden.PlainParams>;

package/dist/src/Functions/Input/List/_.d.ts

@@ -0,0 +1 @@
+export declare const ListInput: FNC<amotify.fn.Input.List.OriginParams>;

package/dist/src/Functions/Input/Segmented/_.d.ts

@@ -0,0 +1 @@
+export declare const Segmented: amotify.fn.Input.Segmented.Types;

package/dist/src/Functions/Input/Select/_.d.ts

@@ -0,0 +1 @@
+export declare const SelectInput: FNC<amotify.fn.Input.Select.PlainParams>;

package/dist/src/Functions/Input/Slider/_.d.ts

@@ -0,0 +1 @@
+export declare const SliderInput: FNC<amotify.fn.Input.Slider.PlainParams>;

package/dist/src/Functions/Input/Switch/_.d.ts

@@ -0,0 +1 @@
+export declare const SwitchInput: FNC<amotify.fn.Input.Switch.PlainParams>;

package/dist/src/Functions/Input/Text.d.ts

@@ -0,0 +1,5 @@
+export declare const TextValidate: (value: any, restrict: amotify.fn.Input.Text.RestrictTypes) => {
+    ok: boolean;
+    body: any;
+};
+export declare const TextInput: FNC<amotify.fn.Input.Text.OriginParams>;

package/dist/src/Functions/Input/TextArea.d.ts

@@ -0,0 +1 @@
+export declare const TextAreaInput: FNC<amotify.fn.Input.TextArea.PlainParams>;

package/dist/src/Functions/Input/Time/Picker.d.ts

@@ -0,0 +1 @@
+export declare const Picker: FNC<amotify.fn.Input.Time.PickerParams>;

package/dist/src/Functions/Input/Time/_.d.ts

@@ -0,0 +1,2 @@
+export declare const TimeInput: FNC<amotify.fn.Input.Time.OriginParams>;
+export declare const TimeFNs: amotify.fn.Input.Time.FNTypes;

package/dist/src/Functions/Input/_.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const ListInputs: amotify.fn.Input.List.Methods & {
+    Origin: (props: amotify.fn.Input.List.OriginParams) => JSX.Element;
+};
+export declare const Input: amotify.fn.Input.Methods;

package/dist/src/Functions/Input/core.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+declare type BoxWrapperParams = {
+    val_status: any;
+    set_status: React.Dispatch<React.SetStateAction<any>>;
+    val_validate: amotify.fn.Input.Validation.Result;
+    params: any;
+    children: ReactElement;
+};
+export declare const BoxWrapper: FNC<BoxWrapperParams>;
+export declare const CommonEffects: {
+    (props: {
+        type?: string;
+        params: plainObject;
+        val_status: amotify.fn.Input.Status.Plain;
+        set_status: React.Dispatch<React.SetStateAction<any>>;
+        val_validate: amotify.fn.Input.Validation.Result;
+        set_validate: React.Dispatch<React.SetStateAction<amotify.fn.Input.Validation.Result>>;
+        DefaultValidation: amotify.fn.Input.Validation.SystemCheck;
+        onUpdateValue?: amotify.fn.Input.OnUpdateValue;
+        onUpdateValidValue?: amotify.fn.Input.OnUpdateValue;
+        ExtraOverrideParams?: plainObject;
+        ExtraStoreParams?: plainObject;
+    }): void;
+};
+export declare const ValidationCheck: {
+    (props: {
+        val_status: amotify.fn.Input.Status.Plain;
+        DefaultValidation: amotify.fn.Input.Validation.SystemCheck;
+        params: any;
+        set_validate: React.Dispatch<React.SetStateAction<amotify.fn.Input.Validation.Result>>;
+    }): void;
+};
+export declare const SubmitForm: (event: React.KeyboardEvent) => boolean;
+export {};

package/dist/src/Functions/Inputs/_.d.ts

@@ -0,0 +1,3 @@
+export declare const Inputs: {
+    TextInput: (params: any) => JSX.Element;
+};

package/dist/src/Functions/Inputs/text.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+declare global {
+    namespace Inputs {
+        type ToneTypes = 'normal' | 'cloud' | 'bottomBorder' | 'plain';
+        namespace Text {
+            type Params = any & React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
+                tone?: ToneTypes;
+            };
+        }
+    }
+}
+export declare const TextInput: (params: Inputs.Text.Params) => JSX.Element;

package/dist/src/Functions/Layout/PageNotFound.d.ts

@@ -0,0 +1 @@
+export declare const PageNotFound: FNC<{}>;

package/dist/src/Functions/Layout/PageRouter.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const PageRouter: React.FC<amotify.fn.Layout.PageRouter.RouterProps>;

package/dist/src/Functions/Layout/PageViewController/parts.d.ts

@@ -0,0 +1 @@
+export declare const PageViewController: FNC<amotify.fn.Layout.PageViewController.Params>;

package/dist/src/Functions/Layout/Plate.d.ts

@@ -0,0 +1 @@
+export declare const Plate: FNC<amotify.fn.Layout.Plate.Params>;

package/dist/src/Functions/Layout/RootViewController/parts.d.ts

@@ -0,0 +1 @@
+export declare const RootViewController: amotify.fn.Layout.RootViewController.Methods;

package/dist/src/Functions/Layout/SwipeView/parts.d.ts

@@ -0,0 +1,2 @@
+export declare const SwipeView: (params: amotify.fn.Layout.SwipeView.Params) => JSX.Element;
+export declare const Core: FNC<amotify.fn.Layout.SwipeView.Params>;

package/dist/src/Functions/Layout/TabBar.d.ts

@@ -0,0 +1 @@
+export declare const TabBar: FNC<amotify.fn.Layout.TabBar.Params>;

package/dist/src/Functions/Layout/_.d.ts

@@ -0,0 +1,2 @@
+declare const Layout: amotify.fn.Layout.Methods;
+export { Layout };

package/dist/src/Functions/Loader/corner.d.ts

@@ -0,0 +1 @@
+export declare const Corner: () => JSX.Element;

package/dist/src/Functions/Loader/mini.d.ts

@@ -0,0 +1,33 @@
+export declare const Mini: (params: amotify.UniStyles.Pargins.Params & amotify.UniStyles.Fonts.Params & amotify.UniStyles.Borders.Params & amotify.UniStyles.FlexGrids.Params & amotify.UniStyles.Sizes.Params & amotify.UniStyles.StyleSets.Params & {
+    backgroundColor?: amotify.UniStyles.Others.BackgroundColorParams | undefined;
+    gradients?: {
+        deg: number;
+        colors: string[];
+    } | undefined;
+    boxShadow?: 0 | 1 | "none" | 2 | 3 | 4 | -1 | -2 | -3 | "borderBox" | undefined;
+    display?: "none" | "block" | "flex" | "grid" | "inlineBlock" | "inlineFlex" | undefined;
+    gap?: amotify.UniStyles.Others.gapParams | undefined;
+    overflow?: amotify.UniStyles.Others.overflowParams | undefined;
+    position?: "relative" | "absolute" | "fixed" | "sticky" | "static" | undefined;
+    top?: amotify.UniStyles.Others.TRBLParams | "topBase" | "topNavigationHeight" | undefined;
+    right?: amotify.UniStyles.Others.TRBLParams | undefined;
+    bottom?: amotify.UniStyles.Others.TRBLParams | undefined;
+    left?: amotify.UniStyles.Others.TRBLParams | undefined;
+    opacity?: "trans" | "low" | "middle" | "high" | "most" | undefined;
+    transition?: "none" | "middle" | "short" | "long" | undefined;
+} & {
+    freeCSS?: React.CSSProperties | undefined;
+    UnderBreakPointStyles?: amotify.UniStyles.Params | undefined;
+    hoverStyles?: amotify.UniStyles.Params | undefined;
+    focusStyles?: amotify.UniStyles.Params | undefined;
+    activeStyles?: amotify.UniStyles.Params | undefined;
+    ssEffectsOnActive?: false | amotify.UniStyles.Others.EffectsOnActiveTypes | amotify.UniStyles.Others.EffectsOnActiveTypes[] | undefined;
+    ssPushable?: boolean | undefined;
+    ssLastChildLossBorder?: false | "bottom" | "right" | undefined;
+} & {
+    showInitial?: boolean | undefined;
+    loaderID?: string | undefined;
+} & {
+    color?: amotify.fn.Loader.Colors | undefined;
+    size?: amotify.fn.Loader.Sizes | undefined;
+}) => JSX.Element;

package/dist/src/Functions/Loader/parts.d.ts

@@ -0,0 +1,3 @@
+export declare const memoryID: string;
+declare const Loader: amotify.fn.Loader.Methods;
+export { Loader };

package/dist/src/Functions/Loader/top.d.ts

@@ -0,0 +1 @@
+export declare const Top: () => JSX.Element;

package/dist/src/Functions/Sheet/parts.d.ts

@@ -0,0 +1,2 @@
+declare const Sheet: amotify.fn.Sheet.Methods;
+export { Sheet };

package/dist/src/Functions/SnackBar/parts.d.ts

@@ -0,0 +1,2 @@
+declare const SnackBar: amotify.fn.SnackBar.Methods;
+export { SnackBar };

package/dist/src/Functions/Table/Data/parts.d.ts

@@ -0,0 +1,3 @@
+export declare const DataFNs: amotify.fn.Tables.Data.FNs;
+export declare const DataComps: amotify.fn.Tables.Data.Comps;
+export declare const DataTable: (params: amotify.fn.Tables.Data.Params) => JSX.Element;

package/dist/src/Functions/Table/Drag/parts.d.ts

@@ -0,0 +1 @@
+export declare const DragTable: FNC<amotify.fn.Tables.Drag.Params>;

package/dist/src/Functions/Table/Normal/parts.d.ts

@@ -0,0 +1 @@
+export declare const NormalTable: FNC<amotify.fn.Tables.Normal.Params>;

package/dist/src/Functions/Table/_.d.ts

@@ -0,0 +1,9 @@
+export declare const Comps: amotify.fn.Tables.CompsMethods;
+export declare const Table: amotify.fn.Tables.Methods;
+export declare const DefaultCellStyles: (type: amotify.fn.Tables.Types, tone: amotify.fn.Tables.Tones) => amotifyUniStyleParams;
+export declare const DefaultCellSystemStyles: (args: {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+}) => amotifyUniStyleParams;

package/dist/src/Functions/Tooltips/parts.d.ts

@@ -0,0 +1,2 @@
+declare const Tooltips: amotify.fn.Tooltips.Methods;
+export { Tooltips };