import Event from '../class/event';
declare const dUtil: {
    Event: typeof Event;
    map: {
        stringify: (map: Map<any, any>) => string | undefined;
        parse: (json: string) => Map<any, any> | undefined;
        deepStringify: (map: Map<any, any>) => string | undefined;
        deepParse: (json: string) => Map<any, any> | undefined;
    };
    includes: typeof import("../util/includes").default;
    forof: (source: any, cb: (key: any, val: any) => void) => void;
    singleton: <T>() => {
        new (): {};
        __instance__: any;
        readonly Instance: T;
        readonly I: T;
    };
    getset: <T_1 = any>(t?: T_1 | undefined) => import("..").Ddan.IGetset<T_1>;
    singletonFactory: <T_2 extends new (...args: any[]) => any>(constructor: T_2) => {
        new (...args: any[]): {
            [x: string]: any;
        };
        __instance__: InstanceType<T_2>;
        getInstance(): InstanceType<T_2>;
        readonly I: InstanceType<T_2>;
    } & T_2;
    copy: (source: any, options?: {
        fields?: string[] | undefined;
        camel?: boolean | undefined;
        pure?: boolean | undefined;
    } & import("..").Ddan.IIgnoreParams) => any;
    clone: (source: any) => any;
    merge: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => {};
    isEmpty: (source: any) => boolean;
    parseValue: (source: any, { number, boolean }?: {
        number?: boolean | undefined;
        boolean?: boolean | undefined;
    }) => any;
    cloneClass: <T_3>(source: T_3) => T_3;
    combine: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => any;
    combines: (objs: any[], options?: import("..").Ddan.IIgnoreParams) => {};
    observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
    find: (obj: any, cb: (k: string, v: any) => boolean) => [string, unknown] | undefined;
    getTag: (value: any) => string;
    getType: (value: any) => string;
    toString: () => string;
    hasOwnProperty: (v: PropertyKey) => boolean;
    propertyIsEnumerable: (v: PropertyKey) => boolean;
    is: (val: any, type: string) => boolean;
    isNumber: (value: any) => boolean;
    isString: (value: any) => boolean;
    isObject: (value: any) => boolean;
    isObjectLike: (value: any) => boolean;
    isPlainObject: (value: any) => boolean;
    isSymbol: (value: any) => boolean;
    isFunction: (value: any) => boolean;
    isArray: (arg: any) => arg is any[];
    isArrayLikeObject: (value: any) => boolean;
    isIndex: (value: any, length: number) => boolean;
    isArrayLike: (value: any) => boolean;
    isPrototype: (value: any) => boolean;
    isArguments: (value: any) => boolean;
    isPromise: (value: any) => boolean;
    isBrowser: boolean;
    isNode: boolean;
    isBlobOrBuffer: (data: any) => boolean;
    isUint8Array: (data: any) => boolean;
    isArrayBuffer: (data: any) => boolean;
    isJSONStr: (str: string) => boolean;
    base64: {
        encode: (input: string) => string;
        decode: (base64Str: string) => string;
        encodeByOss: (input: string) => string;
    };
    tea: {
        TEAKey: string;
        encrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
        decrypt: (v: Uint32Array, teaKey: Uint32Array) => Uint32Array;
        toTeaKey: (str: string) => Uint32Array;
        encode: (plaintext: string, key: string) => string;
        decode: (ciphertext: string, key: string) => string;
        encodeBytes: (plainbytes: Uint8Array, key: string) => Uint8Array;
        decodeBytes: (cipherbytes: Uint8Array, key: string) => Uint8Array;
    };
    uuid: (len?: number, radix?: number) => string;
    guid: (len?: number, prefix?: boolean, sep?: string) => string;
    UUID: (mode?: "lower" | "upper", radix?: number) => string;
    uuid32: (radix?: number) => string;
    randomID: (len?: number, mode?: "lower" | "upper" | "mixin", radix?: number) => string;
    getHexString: (len: number) => string;
    keyNumber: string;
    keyLower: string;
    keyUpper: string;
    keyChars: string;
    str2ab: (content?: string, base64?: boolean) => ArrayBuffer;
    ab2str: (data: ArrayBuffer, base64?: boolean) => string;
    utf8ToBase64: (str: string) => string;
    base64ToUtf8: (base64Str: string) => string;
    getRandomBytes: (length: number) => Uint8Array;
    textEncode: (text: string) => Uint8Array;
    textDecode: (buf: ArrayBufferLike) => string;
    toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
    md5: (input: string | Uint8Array) => string;
    md5Base64: (input: string | Uint8Array) => string;
    toBase64: (input?: string) => string;
    fromBase64: (input?: string) => string;
    bytesToBase64: (bytes: Uint8Array) => string;
    base64ToBytes: (input?: string) => Uint8Array;
    toUtf8: (content: string) => string;
    fromUtf8: (utftext: string) => string;
    toUtf8Bytes: (content: string) => Uint8Array;
    fromUtf8Bytes: (utf8Bytes: Uint8Array) => string;
    pkcs7Padding: (plaintext: Uint8Array, blockSize: number) => Uint8Array;
    pkcs7Unpadding: (ciphertext: Uint8Array) => Uint8Array;
    bytes2str: (bytes: Uint8Array) => string;
    str2bytes: (str?: string) => Uint8Array;
    str2hex: (str: string) => string;
    hex2str: (hexstr: string) => string;
    concatBytes: (...args: Uint8Array[]) => Uint8Array;
    uint32ToBytes: (uint32: Uint32Array) => Uint8Array;
    bytesToUint32: (bytes: Uint8Array) => Uint32Array;
    hex2bytes: (hex: string) => Uint8Array;
    bytes2hex: (bytes: Uint8Array) => string;
    toUint32: (str: string) => Uint32Array;
    fromUint32: (uint32: Uint32Array) => string;
    flatten: <T_4>(data: T_4[], recursive?: boolean, list?: T_4[]) => T_4[];
    gbk: {
        gbkLength: (str: string) => number;
        gbkCut: (source: string, len: number) => string;
    };
    math: {
        random: (max: number) => number;
        randomRange: (min: number, max: number) => number;
        lerp: (start: number, end: number, t: number) => number;
        randoms: (max: number, count?: number, repeat?: boolean) => number[];
        strip: (num: string | number, digits?: number) => number;
        float: (num: string | number, { digits, fixed }?: {
            digits?: number | undefined;
            fixed?: boolean | undefined;
        }) => number;
        radian2degree: (radians: number) => number;
        degree2radian: (degrees: number) => number;
        calcDataSize: (data: number) => {
            gb: number;
            mb: number;
            kb: number;
            b: number;
            total: number;
            desc: string;
        };
    };
    list: {
        stepAction: <T_5>(list: T_5[], func: import("..").Ddan.Task<T_5, void>, stepCount?: number) => void;
        skip: <T_6>(list: T_6[], count: number) => T_6[];
        take: <T_7>(list: T_7[], count: number, skip?: number) => T_7[];
        distinct: <T_8>(list: T_8[]) => T_8[];
        randoms: <T_9>(list: T_9[], count?: number, repeat?: boolean) => T_9[];
        toKV: (list: import("..").Ddan.KV<any>[], key: string, value: string) => import("..").Ddan.KV<any>;
        groupBy: <T_10>(list: T_10[], key: string) => Record<string, T_10[]>;
        first: <T_11>(list: T_11[]) => T_11 | undefined;
        last: <T_12>(list: T_12[]) => T_12 | undefined;
        toList: <T_13>(val: T_13 | T_13[]) => T_13[];
    };
    string: {
        toString: (value: any) => any;
        startCase: (string: any) => any;
        snakeCase: (string: any) => any;
        kebabCase: (string: any) => any;
        camelCase: (string: any) => any;
        upperCase: (string: any) => any;
        upperFirst: (string: any) => any;
        lowerCase: (string: any) => any;
        lowerFirst: (string: any) => any;
        splitOnFirst: (string: any, separator: any) => string[];
        parseValue: (value?: any, { number, boolean }?: {
            number?: boolean | undefined;
            boolean?: boolean | undefined;
        }) => any;
        replace: (source: string, rules: import("..").Ddan.IRegexRule | import("..").Ddan.IRegexRule[]) => string;
        jsonFormat: (jsonString: string) => string;
        toLines: (content: string, separator?: string | RegExp) => string[];
    };
    time: {
        now: () => import("../modules/time/dtime").default;
        isToday: (date: any) => any;
        parseTimestamp: ({ year, month, date, hour, minute, second }: {
            year?: number | undefined;
            month?: number | undefined;
            date?: number | undefined;
            hour?: number | undefined;
            minute?: number | undefined;
            second?: number | undefined;
        }) => number;
        todayZero: () => number;
        format: (time: string | number | Date, reg?: string) => string;
        countdown: (endTime: string | number | Date, reg?: string) => "" | import("..").Ddan.ICountdown;
        dtime: (time: string | number | Date) => import("../modules/time/dtime").default;
        loopFrame: (interval?: number) => import("../modules/time/frame").default;
        getTimezoneOffset: () => number;
        getLocalTime: typeof import("../modules/time/dtime").default.getLocalTime;
        toDate: (time: string | number) => Date | undefined;
        oneDay: number;
        oneHour: number;
        oneMinute: number;
        oneSecond: number;
    };
    obj: {
        copy: (source: any, options?: {
            fields?: string[] | undefined;
            camel?: boolean | undefined;
            pure?: boolean | undefined;
        } & import("..").Ddan.IIgnoreParams) => any;
        clone: (source: any) => any;
        merge: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => {};
        isEmpty: (source: any) => boolean;
        parseValue: (source: any, { number, boolean }?: {
            number?: boolean | undefined;
            boolean?: boolean | undefined;
        }) => any;
        cloneClass: <T_3>(source: T_3) => T_3;
        combine: (target: any, source: any, options?: import("..").Ddan.IIgnoreParams) => any;
        combines: (objs: any[], options?: import("..").Ddan.IIgnoreParams) => {};
        observe: (obj: any, key: any, watchFun: any, owner: any, deep?: boolean) => void;
        find: (obj: any, cb: (k: string, v: any) => boolean) => [string, unknown] | undefined;
    };
    rule: {
        validateId: (content: any) => boolean;
        validatePhone: (content: any) => boolean;
        validator: (rules: import("../modules/rule/async-validator").Rules) => import("../modules/rule/async-validator").default;
        validate: (rules: import("../modules/rule/async-validator").Rules, source_: import("../modules/rule/async-validator").Values, o?: any, oc?: any) => Promise<import("../modules/rule/async-validator").Values>;
        isChinese: (content: string) => boolean;
        isNumber: (content: string) => boolean;
        isFloat: (content: string) => boolean;
        isPhoneNumber: (content: any) => boolean;
    };
    regex: {
        pattern: {
            num: string;
            zh: string;
            en: string;
        };
        regex: (patt: string, modifiers?: "i" | "g" | "m" | undefined) => RegExp;
        entire: {
            chinese: RegExp;
            real: RegExp;
            cssReal: RegExp;
            id: RegExp;
            yyyyMMdd: RegExp;
        };
    };
};
export default dUtil;