import Http from '../modules/http';
declare const dWeb: {
    Ecdh: typeof import("../modules/browser/ecdh").default;
    fetch: {
        getDataURL: (url: string, init?: RequestInit | undefined) => Promise<[null, {
            contentType: string;
            dataUrl: string;
        }] | [any, undefined]>;
        getArrayBuffer: (url: string, init?: RequestInit | undefined) => Promise<[any, undefined] | [null, ArrayBuffer]>;
        getJson: (url: string, init?: RequestInit | undefined) => Promise<[any, undefined] | [null, any]>;
        download: (url: string, opts?: {
            success?: ((buffer: Uint8Array) => void) | undefined;
            progress?: ((percentage: number, current: number, total: number) => void) | undefined;
            fail?: ((error: Error) => void) | undefined;
        }) => Promise<Uint8Array | undefined>;
        getText: (url: string, init?: RequestInit | undefined) => Promise<[any, undefined] | [null, string]>;
        cache: (url: string, cache?: RequestCache) => Promise<[any, undefined] | [null, boolean]>;
        Fetch: {
            new (config?: {
                baseURL?: string | undefined;
                headers?: Record<string, string> | undefined;
            }): {
                baseURL: string;
                defaultHeaders: Record<string, string>;
                query(options: {
                    url: string;
                    method?: string | undefined;
                    headers?: Record<string, any> | undefined;
                    cache?: RequestCache | undefined;
                }, params?: object): Promise<string>;
                request(url: string, args?: {
                    params?: Record<string, any> | undefined;
                    method?: "POST" | "GET" | undefined;
                    baseURL?: string | undefined;
                    headers?: Record<string, string> | undefined;
                    cache?: RequestCache | undefined;
                }): Promise<string>;
                formatError(response: Response | null, responseText: string | null, networkError?: any): any;
                ask(url: string, args?: {
                    params?: Record<string, any> | undefined;
                    method?: "POST" | "GET" | undefined;
                    baseURL?: string | undefined;
                    headers?: Record<string, string> | undefined;
                    cache?: RequestCache | undefined;
                }): Promise<[any, undefined] | [null, any]>;
            };
        };
    };
    Http: typeof Http;
    css: {
        stringify: (styleObj: Record<string, string | number>) => string;
        parse: (styleStr: string, { camel, pure }?: {
            camel?: boolean | undefined;
            pure?: boolean | undefined;
        }) => {} | undefined;
        fixValue: (value: string | number, unit?: string) => string | number;
        style: (cssKV: Record<string, any>, unit?: string) => string;
        commonFields: string[];
    };
    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;
    };
    icon: import("../class/icon").DIcon;
    html: {
        dataURLtoFile: (dataurl: any, filename: any) => File;
        dataURLtoBlob: (dataurl: any) => Blob;
        blobToFile: (blob: any, fileName: string) => any;
        readAsDataURL: (file: any, cb: any) => void;
        downloadUrl: (url: string, filename?: string, checkSomeOrigin?: boolean) => void;
        download: (urlOrFile: string | Blob | MediaSource, filename?: string) => void;
        downloadFile: (data: Blob | MediaSource, filename?: string) => void;
        downloadImage: (url: string) => Promise<void> | undefined;
        watermark: (text: string, { width, height, angle, fillStyle, font, textAlign, textBaseline, }?: {
            width?: number | undefined;
            height?: number | undefined;
            angle?: number | undefined;
            fillStyle?: string | undefined;
            font?: string | undefined;
            textAlign?: "center" | "end" | "left" | "right" | "start" | undefined;
            textBaseline?: "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top" | undefined;
        }) => string;
        copyText: (text: string, legacy?: boolean) => Promise<boolean>;
        queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
        isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
        legacyCopy: (text: string) => boolean;
        takeHtmlLinks: (htmlContent: string) => never[];
        takeHtml: (htmlContent: string, regex: RegExp) => string[];
        toBlobUrl: (part: BlobPart, mime?: string) => string;
        workerURL: (fn: Function) => string;
        getVideoMetadata: (source: string | Blob | MediaSource | File, timeout?: number) => Promise<{
            width: number;
            height: number;
            duration: number;
        }>;
        getImageMetadata: (source: string | Blob | File, timeout?: number) => Promise<{
            width: number;
            height: number;
        }>;
        ElementObserver: typeof import("../modules/html/elementObserver").ElementObserver;
        watchTextChange: (element: HTMLElement, callback: (newText: string, oldText: string) => void) => (() => void) | undefined;
        watchAttrChange: (element: HTMLElement | null | undefined, callback: (attrName: string, newValue: string | null, oldValue: string | null) => void, attrs?: string[] | undefined) => (() => void) | undefined;
        watchElementChange: (element: Element | null, options?: {
            onText?: ((newText: string, oldText: string) => void) | undefined;
            onAttr?: ((name: string, newValue: string | null, oldValue: string | null) => void) | undefined;
            attrFilter?: string[] | null | undefined;
        } | undefined) => (() => void) | undefined;
        waitForElement: (selector: string, timeout?: number) => Promise<Element | null>;
    };
    rsa: {
        generateKeys: () => Promise<{
            publicKey: string;
            publicKeyPem: string;
            privateKey: string;
            privateKeyPem: string;
        }>;
        encrypt: (data: string, publicKey: string) => Promise<string>;
        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
        encode: (data: string) => Promise<string>;
        decode: (encryptedBase64: string) => Promise<string>;
    };
    cipher: {
        aesGcmEncrypt: (text: string, aesKey: CryptoKey, ivFirst?: boolean) => Promise<string>;
        aesGcmDecrypt: (encryptedBase64: string, aesKey: CryptoKey, ivFirst?: boolean) => Promise<string>;
        aesCryptoKey: (sharedBase64: string) => Promise<CryptoKey | null>;
        aesCryptoKeyFromHkdf: (sharedBase64: string, saltBase64: string, infoBase64: string) => Promise<CryptoKey | null>;
        aesGcmKey: (rawData: BufferSource) => Promise<CryptoKey | null>;
        rawKeyHex: (cryptoKey: CryptoKey) => Promise<string>;
        rawKeyBytes: (cryptoKey: CryptoKey) => Promise<Uint8Array | null>;
    };
};
export default dWeb;