import * as allBase64 from './base64';
import * as allCookie from './cookie';
import * as allDate from './date';
import * as allDom from './dom';
import * as allEmitter from './emitter';
import * as allQs from './qs';
import * as allString from './string';
import * as allUrl from './url';
import * as allAjax from './ajax';
import * as allCss from './css';
import * as allJsonp from './jsonp';
import { default as classNamesAlias } from './classNames';
import { default as delayAlias } from './delay';
import { default as md5Alias } from './md5';
import { default as noopAlias } from './noop';
import { default as numberFormatAlias } from './numberFormat';
import { default as rafAlias } from './raf';
import { default as randomNumbersAlias } from './randomNumbers';
import { default as randomStringAlias } from './randomString';
import { default as uuidAlias } from './uuid';
declare namespace micell {
    type Base64DecodeOptions = allBase64.Base64DecodeOptions;
    type Base64DecodeFileOptions = allBase64.Base64DecodeFileOptions;
    type CookieDecoder = allCookie.CookieDecoder;
    type CookieEncoder = allCookie.CookieEncoder;
    type CookieOptions = allCookie.CookieOptions;
    type Cookies = allCookie.Cookies;
    type ParsedDate = allDate.ParsedDate;
    type TimeAgo = allDate.TimeAgoLocale;
    type AnyFunction = allDom.AnyFunction;
    type CreateEventOptions = allDom.CreateEventOptions;
    type InsertScriptOptions = allDom.InsertScriptOptions;
    type ScrollToOptions = allDom.ScrollToOptions;
    type Viewport = allDom.Viewport;
    type Listener = allEmitter.Listener;
    type EventType = allEmitter.EventType;
    type Events = allEmitter.Events;
    type Query = allQs.Query;
    type TruncateOptions = allString.TruncateOptions;
    type URLObject = allUrl.URLObject;
    type URLParts = allUrl.URLParts;
    type AjaxOptions = allAjax.AjaxOptions;
    type CSSProps = allCss.CSSProps;
    type JsonpOptions = allJsonp.JsonpOptions;
    const ajax: typeof allAjax.default;
    const classNames: typeof classNamesAlias;
    const css: typeof allCss.default;
    const delay: typeof delayAlias;
    const download: (file: string | Blob | File, name?: string) => void;
    const jsonp: typeof allJsonp.default;
    const md5: typeof md5Alias;
    const noop: typeof noopAlias;
    const numberFormat: typeof numberFormatAlias;
    const raf: typeof rafAlias;
    const randomNumbers: typeof randomNumbersAlias;
    const randomString: typeof randomStringAlias;
    const uuid: typeof uuidAlias;
    namespace base64 {
        const decode: typeof import("./base64/decode").default;
        const decodeFile: typeof import("./base64/decodeFile").default;
        const encode: typeof import("./base64/encode").default;
        const encodeFile: typeof import("./base64/encodeFile").default;
    }
    namespace char {
        const isAlphabetic: (ch: string) => boolean;
        const isAlphanumeric: (ch: string) => boolean;
        const isASCII: (ch: string) => boolean;
        const isCJK: (ch: string) => boolean;
        const isControl: (ch: string) => boolean;
        const isDigit: (ch: string) => boolean;
        const isGraph: (ch: string) => boolean;
        const isHexadecimal: (ch: string) => boolean;
        const isLower: (ch: string) => boolean;
        const isPrint: (ch: string) => boolean;
        const isPunctuation: (ch: string) => boolean;
        const isSpace: (ch: string) => boolean;
        const isUpper: (ch: string) => boolean;
    }
    namespace cookie {
        const get: typeof import("./cookie/get").default;
        const getAll: typeof import("./cookie/getAll").default;
        const getJson: typeof import("./cookie/getJson").default;
        const getRaw: typeof import("./cookie/getRaw").default;
        const isEnabled: typeof import("./cookie/isEnabled").default;
        const remove: typeof import("./cookie/remove").default;
        const set: typeof import("./cookie/set").default;
        const setJson: typeof import("./cookie/setJson").default;
        const setRaw: typeof import("./cookie/setRaw").default;
    }
    namespace date {
        const diff: typeof import("./date/diff").default;
        const format: (date: string | number | Date, format?: string, isUTC?: boolean) => string;
        const parse: typeof import("./date/parse").default;
        const timeAgo: import("./date/timeAgo").TimeAgo;
    }
    namespace dom {
        const clientX: typeof import("./dom/clientX").default;
        const clientY: typeof import("./dom/clientY").default;
        const createEvent: typeof import("./dom/createEvent").default;
        const domReady: typeof import("./dom/domReady").default;
        const insertScript: typeof import("./dom/insertScript").default;
        const isElement: typeof import("./dom/isElement").default;
        const isInViewport: typeof import("./dom/isInViewport").default;
        const isWindow: typeof import("./dom/isWindow").default;
        const pageHeight: typeof import("./dom/pageHeight").default;
        const pageWidth: typeof import("./dom/pageWidth").default;
        const pageX: typeof import("./dom/pageX").default;
        const pageY: typeof import("./dom/pageY").default;
        const scrollTo: typeof import("./dom/scrollTo").default;
        const scrollX: typeof import("./dom/scrollX").default;
        const scrollY: typeof import("./dom/scrollY").default;
        const viewport: typeof import("./dom/viewport").default;
    }
    namespace easing {
        const cubicBezier: typeof import("./easing/cubicBezier").default;
        const ease: (x: number) => number;
        const easeIn: (x: number) => number;
        const easeInOut: (x: number) => number;
        const easeOut: (x: number) => number;
        const linear: (x: number) => number;
    }
    namespace emitter {
        const create: typeof import("./emitter/create").default;
        const emit: any;
        const Emitter: typeof import("./emitter/Emitter").default;
        const getListeners: any;
        const once: any;
        const on: any;
        const off: any;
    }
    namespace lang {
        const isArray: import("./_internal/isType").ToStringFunc;
        const isBoolean: import("./_internal/isType").ToStringFunc;
        const isDate: import("./_internal/isType").ToStringFunc;
        const isError: import("./_internal/isType").ToStringFunc;
        const isFunction: (o: any) => boolean;
        const isNil: (o: any) => boolean;
        const isNull: (o: any) => boolean;
        const isNumber: import("./_internal/isType").ToStringFunc;
        const isObject: import("./_internal/isType").ToStringFunc;
        const isRegExp: import("./_internal/isType").ToStringFunc;
        const isString: import("./_internal/isType").ToStringFunc;
        const isUndefined: (o: any) => boolean;
    }
    namespace path {
        const basename: (path: string, ext?: string, sep?: string) => string;
        const dirname: (path: string, sep?: string) => string;
        const extname: (path: string) => string;
        const join: (...args: string[]) => string;
    }
    namespace qs {
        const get: typeof import("./qs/get").default;
        const parse: typeof import("./qs/parse").default;
        const stringify: typeof import("./qs/stringify").default;
    }
    namespace regex {
        const ascii: RegExp;
        const decimal: RegExp;
        const digit: RegExp;
        const domain: RegExp;
        const email: RegExp;
        const hexColor: RegExp;
        const hsl: RegExp;
        const hsla: RegExp;
        const integer: RegExp;
        const ipv4: RegExp;
        const ipv6: RegExp;
        const isAscii: (string: string) => boolean;
        const isDecimal: (string: string) => boolean;
        const isDigit: (string: string) => boolean;
        const isDomain: (string: string) => boolean;
        const isEmail: (string: string) => boolean;
        const isHexColor: (string: string) => boolean;
        const isHsl: (string: string) => boolean;
        const isHsla: (string: string) => boolean;
        const isIP: (string: string) => boolean;
        const isIPv4: (string: string) => boolean;
        const isIPv6: (string: string) => boolean;
        const isInteger: (string: string) => boolean;
        const isQQ: (string: string) => boolean;
        const isRealNumber: (string: string) => boolean;
        const isRgb: (string: string) => boolean;
        const isRgba: (string: string) => boolean;
        const qq: RegExp;
        const realNumber: RegExp;
        const rgb: RegExp;
        const rgba: RegExp;
    }
    namespace string {
        const countChars: typeof import("./string/countChars").default;
        const countLines: (text: string, newline?: string) => number;
        const escapeRegexp: typeof import("./string/escapeRegexp").default;
        const firstChar: (str: string) => string;
        const isValidJSON: typeof import("./string/isValidJSON").default;
        const lastChar: (str: string) => string;
        const truncate: typeof import("./string/truncate").default;
    }
    namespace url {
        const isAbsolute: typeof import("./url/isAbsolute").default;
        const join: (...args: string[]) => string;
        const parse: typeof import("./url/parse").default;
        const stringify: typeof import("./url/stringify").default;
    }
    namespace ua {
        const isAndroid: (ua?: string) => boolean;
        const isIOS: (ua?: string) => boolean;
        const isIPad: (ua?: string) => boolean;
        const isIPhone: (ua?: string) => boolean;
        const isLinux: (ua?: string) => boolean;
        const isMacOS: (ua?: string) => boolean;
        const isMobile: (ua?: string) => boolean;
        const isTablet: (ua?: string) => boolean;
        const isWeChat: (ua?: string) => boolean;
        const isWindows: (ua?: string) => boolean;
    }
}
export default micell;