/// <reference types="node" />
export { default as Encoders } from './Encoders';
export { default as Hooks } from './Hooks';
import { default as conf } from './conf';
export { default as conf } from './conf';
export { default as Cookie } from './Cookie';
export { default as debounce } from './debounce';
export { default as Docker } from './Docker';
export { default as Git } from './Git';
export { default as GPS } from './GPS';
export { default as IO } from './IO';
export { default as QueryParams } from './QueryParams';
export { default as Shell } from './Shell';
export { default as Storage } from './Storage';
export { default as Time } from './Time';
export { default as Tween } from './Tween';
export { default as URL } from './URL';
import { default as wait } from './wait';
export { default as wait } from './wait';
export { default as WebIO } from './WebIO';
declare const _default: {
    Encoders: {
        bytesToStr: typeof import("./Encoders/bytesToStr").default;
        hexToStr: typeof import("./Encoders/hexToStr").default;
        bufToStr: typeof import("./Encoders/bufToStr").default;
        b64ToStr: typeof import("./Encoders/b64ToStr").default;
        strToBytes: typeof import("./Encoders/strToBytes").default;
        hexToBytes: typeof import("./Encoders/hexToBytes").default;
        bufToBytes: typeof import("./Encoders/bufToBytes").default;
        b64ToBytes: typeof import("./Encoders/b64ToBytes").default;
        strToHex: typeof import("./Encoders/strToHex").default;
        bytesToHex: typeof import("./Encoders/bytesToHex").default;
        bufToHex: typeof import("./Encoders/bufToHex").default;
        b64ToHex: typeof import("./Encoders/b64ToHex").default;
        strToBuf: typeof import("./Encoders").strToBuf;
        bytesToBuf: typeof import("./Encoders/bytesToBuf").default;
        hexToBuf: typeof import("./Encoders/hexToBuf").default;
        b64ToBuf: typeof import("./Encoders/b64ToBuf").default;
        strToB64: typeof import("./Encoders/strToB64").default;
        bytesToB64: typeof import("./Encoders/bytesToB64").default;
        hexToB64: typeof import("./Encoders/hexToB64").default;
        bufToB64: typeof import("./Encoders/bufToB64").default;
        decToLE8HexString: typeof import("./Encoders/decToLE8HexString").default;
    };
    Hooks: {
        useEvent: (element: any, eventName: any, handler: any, debounceMs?: any) => void;
        whenClick: (element: any, callback: any, { resizeable }?: {
            resizeable?: boolean;
        }) => void;
        whenDragged: typeof import("./Hooks/whenDragged").default;
    };
    conf: typeof conf;
    Cookie: {
        has(name: any): boolean;
        get(name?: any): any;
        set(name: any, value: any, { domain, path, expires, maxAge, sameSite, secure }?: {
            domain?: any;
            path?: any;
            expires?: any;
            maxAge?: any;
            sameSite?: any;
            secure?: any;
        }): string;
        remove(name: any, { domain, path }?: {
            domain?: any;
            path?: any;
        }): string;
        map(): {};
    };
    debounce: (task: any, ms?: number, onStartCounting?: any) => () => void;
    Docker: {
        getPods: () => Promise<{}>;
        tailLogs: (podNames: any, n?: string) => Promise<import("stream").PassThrough>;
        restartPod: (podName: any) => Promise<any>;
        getStats: () => Promise<{}>;
    };
    Git: {
        getCommit: (cwd?: any) => Promise<unknown>;
        getBranch: (cwd?: any) => Promise<unknown>;
        getCommitTs: (cwd?: any, outputFormat?: string) => Promise<unknown>;
    };
    GPS: {
        userLocCache: any;
        userBlockedLocation: boolean;
        fetchUserLoc: (maxWaitMs?: number) => Promise<unknown>;
        calcDistance: (lat1: any, lng1: any, lat2: any, lng2: any) => string;
        addListener(eventName: string | symbol, listener: (...args: any[]) => void): any;
        on(eventName: string | symbol, listener: (...args: any[]) => void): any;
        once(eventName: string | symbol, listener: (...args: any[]) => void): any;
        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): any;
        off(eventName: string | symbol, listener: (...args: any[]) => void): any;
        removeAllListeners(event?: string | symbol): any;
        setMaxListeners(n: number): any;
        getMaxListeners(): number;
        listeners(eventName: string | symbol): Function[];
        rawListeners(eventName: string | symbol): Function[];
        emit(eventName: string | symbol, ...args: any[]): boolean;
        listenerCount(eventName: string | symbol, listener?: Function): number;
        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): any;
        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): any;
        eventNames(): (string | symbol)[];
    };
    IO: {
        readJson: (path: string, defaultValue?: any) => Promise<any>;
        writeJson: (path: string, json: object) => Promise<any>;
        readFile: (path: string, defaultValue?: any) => Promise<any>;
        writeFile: (path: string, data: any) => Promise<any>;
        removeFile: (path: any) => Promise<any>;
        oneJson: (dirPath: any, { desire }?: {
            desire?: string;
        }) => Promise<any>;
        oneFile: (dirPath: any, { desire }?: {
            desire?: string;
        }) => Promise<any>;
        readFileWithVirtuals: (rootPath: any, path: any) => Promise<any>;
        readDir: (path: any, { absPaths, sort }?: {
            absPaths?: boolean;
            sort?: string;
        }) => Promise<any>;
        writeBackupFile: (path: any, data: any, maxFiles?: number) => Promise<{
            removed: any[];
            numFilesFound: any;
        }>;
        pruneFiles: (dirPath: any, maxFiles?: number) => Promise<{
            removed: any[];
            numFilesFound: any;
        }>;
        isFile: (path: any) => Promise<any>;
        isDir: (path: any) => Promise<any>;
        getModifiedInstant: (path: any) => Promise<any>;
        getModifiedTs: (path: any, outputFormat?: string) => Promise<any>;
        getCreatedInstant: (path: any) => Promise<any>;
        getReadableFileSize: (path: any) => Promise<string>;
        getStat: (path: any) => Promise<any>;
        expandPath: (path: any) => any[];
        toFileName: (path: any) => any;
        getDiskUsage: () => Promise<{
            size: string;
            used: string;
            available: string;
            percentUsed: string;
        }>;
        execCmds: (cmds: any, cwd: any, out: any) => Promise<{
            code: any;
            outputLines: any[];
            message: string;
        }>;
        execCmd: (cmd: string, cwd?: string, out?: (data: string) => any) => Promise<{
            code: number;
            outputLines: string[];
            message: string;
        }>;
    };
    QueryParams: {
        readonly map: {};
        all(): any[];
        get(name: any): any;
        getLoc(): {
            lat: number;
            lng: number;
        };
        getPos(): {
            coords: {
                latitude: number;
                longitude: number;
            };
        };
        getCurrentInstant(): number;
        isSandbox(): boolean;
        isDemo(): boolean;
        isDebug(): boolean;
    };
    Shell: {
        one: (cmd: any, args: any, { cwd, shell, ...other }?: {
            cwd?: any;
            shell?: boolean;
        }) => Promise<unknown>;
        tail: (cmd: any, args: any, { cwd, shell, ...other }?: {
            cwd?: any;
            shell?: boolean;
        }) => Promise<any>;
    };
    Storage: {
        get(key: any, defaultValue?: any): any;
        set(key: any, val: any): void;
        remove(key: any): void;
    };
    Time: {
        nowInstant: () => number;
        timestampJstToInstant: (timestamp: any, inputFormat?: string) => number;
        instantToTimestampJst: (instant: any, outputFormat?: string) => string;
        nowTimestampUtc: (offsetMillis?: number, outputFormat?: string) => string;
        nowTimestampLocal: (offsetMillis?: number, outputFormat?: string) => string;
        nowTimestampJst: (offsetMillis?: number, outputFormat?: string) => string;
        today10amJst: (offsetMillis?: number, outputFormat?: string) => string;
        nowYmdJst: (del?: string) => string;
        nowHmsJst: (del?: string) => string;
        instantToYmd: (instant: any, del?: string) => string;
        ymdToTimestamp: (ymd: any, inputFormat?: string, outputFormat?: string) => string;
        timestampToJstTimestamp: (timestamp: any, inputFormat?: string, outputFormat?: string) => string;
    };
    Tween: {
        disableNativeTouchScrolling: () => void;
        tween: (fromValue: any, toValue: any, options: any) => Promise<void>;
        tweenState: (component: any, tweenKey: any, { onStart, tweeners, onEnd, duration, easing }: {
            onStart: any;
            tweeners: any;
            onEnd: any;
            duration: any;
            easing: any;
        }) => import("@tweenjs/tween.js").Tween<{
            value: number;
        }>;
    };
    URL: {
        parseUrl: (urlString: any) => {
            href: string;
            path: string;
            queryMap: {};
        };
    };
    wait: typeof wait;
    WebIO: {
        downloadText: (filename: any, string: any) => void;
        downloadURI: (uri: any, name: any) => void;
        downloadZip: (zipName: any, folderStructureObject: any) => void;
        readDataUrl: (event: any) => Promise<unknown>;
        readFileText: (file: any) => Promise<unknown>;
        readImageDrop: (event: any) => Promise<unknown>;
    };
};
export default _default;