declare const dHook: {
    qs: {
        parse: (qs: any, { sep, eq, max, multiple, uri, parseNumber, parseBoolean }?: {
            sep?: string | undefined;
            eq?: string | undefined;
            max?: number | undefined;
            multiple?: boolean | undefined;
            uri?: boolean | undefined;
            parseNumber?: boolean | undefined;
            parseBoolean?: boolean | undefined;
        }) => {};
        stringify: (obj: any, { sep, eq, name, uri, cleanZero, cleanNull, cleanWhitespace }?: {
            sep?: string | undefined;
            eq?: string | undefined;
            name?: null | undefined;
            uri?: boolean | undefined;
            cleanZero?: boolean | undefined;
            cleanNull?: boolean | undefined;
            cleanWhitespace?: boolean | undefined;
        }) => string;
        https: (url: string) => string;
        parseUrl: (url: string) => {
            pathname: string;
            params: {};
            route: string;
            page: string;
            name: string;
            withoutExtension: string;
            extname: string;
            hash: string;
            href: string;
            url: string;
            origin: string;
            host: string;
            protocol: string;
            hostname: string;
            port: string;
            query: string;
        };
        parsePath: (url: string) => {
            route: string;
            page: string;
            name: string;
            withoutExtension: string;
            extname: string;
        };
        parseHost: (url: string) => import("..").Ddan.IHttpHost;
        join: (...args: string[]) => string;
        urlJoin: (...parts: string[]) => string;
        shExpMatch: (text: string, pattern: string) => boolean;
        isLocalIPAddress: (addr: string) => boolean;
        parseFileUrl: (url: string) => {
            href: string;
            file: string;
            url: string;
            protocol: string;
            host: string;
            query: string;
            params: {};
        };
        isIP: (addr: string) => boolean;
        isIPv4: (addr: string) => boolean;
        isIPv6: (addr: string) => boolean;
        isPrivateIP: (addr: string) => boolean;
        isPrivateIPv4: (addr: string) => boolean;
        isPrivateIPv6: (addr: string) => boolean;
    };
    ali: {
        urlAuthA: (uri: string, exp?: number, key?: string) => string;
    };
    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;
    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;
    };
    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[];
    sleep: (ms?: number) => Promise<unknown>;
    run: <T_3 = any>(task?: import("..").Ddan.PFunction<T_3> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_3]>;
    exec: (func: import("..").Ddan.Function, taskId?: string) => import("..").Ddan.PSafeResult<any>;
    debounce: typeof import("../modules/hook/modules/debounce").default;
    throttle: typeof import("../modules/hook/modules/throttle").default;
    task: (param?: import("..").Ddan.Func1<any, any> | undefined) => import("../class/pipeTask").default;
    mutex: typeof import("../modules/hook/modules/mutex").default;
    polling: typeof import("../modules/hook/modules/polling").default;
    pipe: (func: import("..").Ddan.Function, callback?: ((result: import("..").Ddan.SafeResult<any>) => void) | undefined) => import("../modules/hook/modules/pipeline").default;
    pipeline: (max?: number) => import("../modules/hook/modules/pipeline").default;
    safeTask: (func: import("..").Ddan.Function, callback?: ((result: import("..").Ddan.SafeResult<any>) => void) | undefined) => import("../modules/hook/modules/safeTask").default;
    pipeAsync: (func: import("..").Ddan.Function) => import("..").Ddan.PSafeResult<any>;
    runAsync: <T_4 = any>(func: any, opts?: {
        pipe?: boolean | undefined;
        mutex?: string | undefined;
    }) => Promise<T_4 | undefined>;
    anySuccess: (promises: Promise<any>[]) => Promise<boolean>;
    bezier1: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
    bezier2: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, p2: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
    bezier3: (p0: import("..").Ddan.IPoint, p1: import("..").Ddan.IPoint, p2: import("..").Ddan.IPoint, p3: import("..").Ddan.IPoint, t: number) => import("..").Ddan.IPoint;
    bezier: (points: import("..").Ddan.IPoint[], t: number) => import("..").Ddan.IPoint;
    bezierCurve: (points: import("..").Ddan.IPoint[], t: number) => import("..").Ddan.IPoint;
    lerpAverage: (points: import("..").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
    proportion: (start: number, end: number, current: number) => number;
    logString: (data: any) => string;
    logParse: (logStr: string) => string;
    logRString: (data: any) => Promise<string>;
    logRParse: (logStr: string) => Promise<string>;
    to: <T_5 = any, U extends object = any>(promise: Promise<T_5>, errorExt?: object | undefined, fn?: import("..").Ddan.noop | undefined) => Promise<[null, T_5] | [U, undefined]>;
    go: <T_6 = any>(task?: import("..").Ddan.PFunction<T_6> | undefined, fn?: import("..").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_6]>;
    delay: (ms?: number) => Promise<unknown>;
    safeRun: <T_7 = any>(func: any, fn?: import("..").Ddan.noop | undefined) => Promise<[any, undefined] | [null, T_7]>;
    toError: (value: any) => any;
    timeout: <T_8 = any>(task?: import("..").Ddan.PFunction<T_8> | undefined, ms?: number, desc?: string) => Promise<[any, undefined] | [null, T_8]>;
    getValueIf: <T_9 = any, F = any>(condition: boolean | (() => boolean), trueValue: T_9 | (() => T_9), falseValue?: F | (() => F) | undefined) => T_9 | F | undefined;
    resolveValue: <T_10 = any>(value: T_10 | (() => T_10)) => T_10;
    compareVersion: (ver1: string, ver2: string) => 0 | 1 | -1;
    toOpen: (content: string, defaultOpen?: boolean) => boolean;
    jsonParse: <T_11 = unknown>(text: string, defaultValue?: T_11 | null) => T_11 | null;
    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_12>(data: T_12[], recursive?: boolean, list?: T_12[]) => T_12[];
    flattenPath: (data: Record<string, any>) => Record<string, any>;
    normalizeStructure: (data: any, prevData: any) => void;
    diffPath: (data: Record<string, any>, prevData: Record<string, any>) => Record<string, any>;
    shExpMatch: (text: string, pattern: string) => boolean;
    shExpMatchs: (text: string, pattern: string | string[]) => boolean;
    copy: (source: any, options?: {
        fields?: string[] | undefined;
        camel?: boolean | undefined;
        pure?: boolean | undefined;
        ignoreNull?: boolean | undefined;
        ignoreZero?: boolean | undefined;
        ignoreEmptyArray?: boolean | undefined;
        ignoreEmptyString?: boolean | undefined;
    }) => any;
    clone: (source: any, weakMap?: WeakMap<object, any>) => any;
    cloneClass: <T_13>(source: T_13) => T_13;
    isEqual: <T_14 = any>(value: T_14, other: T_14, depth?: number) => boolean;
    isEqualArray: (value: any[], other: any[], depth?: number) => boolean;
    isEqualObject: (value: Record<string, any>, other: Record<string, any>, depth?: number) => boolean;
    isEqualValue: <T_15>(value: T_15, other: T_15, type: string) => boolean;
    isEqualAB: (value: ArrayBuffer, other: ArrayBuffer) => boolean;
    isEqualDeep: <T_16>(value: T_16, other: T_16) => boolean;
};
export default dHook;