mphttpx 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,823 @@
+declare class TextEncoderP implements TextEncoder {
+    get encoding(): string;
+    encode(input?: string): Uint8Array<ArrayBuffer>;
+    encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare const TextEncoderE: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+
+declare const state$9: unique symbol;
+declare class TextDecoderP implements TextDecoder {
+    constructor(utfLabel?: string, { fatal, ignoreBOM }?: {
+        fatal?: boolean | undefined;
+        ignoreBOM?: boolean | undefined;
+    });
+    [state$9]: TextDecoderState;
+    get encoding(): string;
+    get fatal(): boolean;
+    get ignoreBOM(): boolean;
+    decode(buffer?: TAllowSharedBufferSource, { stream }?: {
+        stream?: boolean | undefined;
+    }): string;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class TextDecoderState {
+    fatal: boolean;
+    ignoreBOM: boolean;
+    _bomSeen: boolean;
+    _partial: number[];
+}
+type TAllowSharedBufferSource = NonNullable<Parameters<TextDecoder["decode"]>[0]>;
+declare const TextDecoderE: {
+    new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    prototype: TextDecoder;
+};
+
+declare const state$8: unique symbol;
+
+declare class EventP implements Event {
+    static readonly NONE = 0;
+    static readonly CAPTURING_PHASE = 1;
+    static readonly AT_TARGET = 2;
+    static readonly BUBBLING_PHASE = 3;
+    constructor(type: string, eventInitDict?: EventInit);
+    [state$8]: EventState;
+    get type(): string;
+    get bubbles(): boolean;
+    get cancelable(): boolean;
+    get composed(): boolean;
+    get target(): EventTarget | null;
+    get currentTarget(): EventTarget | null;
+    get eventPhase(): number;
+    readonly NONE = 0;
+    readonly CAPTURING_PHASE = 1;
+    readonly AT_TARGET = 2;
+    readonly BUBBLING_PHASE = 3;
+    get srcElement(): EventTarget | null;
+    cancelBubble: boolean;
+    get defaultPrevented(): boolean;
+    get returnValue(): boolean;
+    set returnValue(value: boolean);
+    get isTrusted(): boolean;
+    get timeStamp(): number;
+    composedPath(): EventTarget[];
+    initEvent: (type: string, bubbles?: boolean, cancelable?: boolean) => void;
+    preventDefault: () => void;
+    stopImmediatePropagation: () => void;
+    stopPropagation(): void;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class EventState {
+    static TimeStamp: number;
+    type: string;
+    bubbles: boolean;
+    cancelable: boolean;
+    composed: boolean;
+    target: EventTarget | null;
+    currentTarget: EventTarget | null;
+    eventPhase: number;
+    defaultPrevented: boolean;
+    returnValue: boolean;
+    isTrusted: boolean;
+    timeStamp: number;
+    _passive: boolean;
+    _dispatched: boolean;
+    _preventDefaultCalled: boolean;
+    _stopImmediatePropagationCalled: boolean;
+}
+declare const EventE: {
+    new (type: string, eventInitDict?: EventInit): Event;
+    prototype: Event;
+    readonly NONE: 0;
+    readonly CAPTURING_PHASE: 1;
+    readonly AT_TARGET: 2;
+    readonly BUBBLING_PHASE: 3;
+};
+
+declare const state$7: unique symbol;
+
+declare class EventTargetP implements EventTarget {
+    constructor();
+    [state$7]: EventTargetState;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+    dispatchEvent(event: Event): boolean;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class EventTargetState {
+    constructor(target: EventTargetP);
+    target: EventTargetP;
+    executors: Executor[];
+    fire(event: EventP): boolean;
+    reply(signal: AbortSignal, executor: Executor): void;
+}
+declare class Executor {
+    static extract(cb: EventListenerOrEventListenerObject | null): EventListener | null;
+    constructor(type: string, callback: EventListenerOrEventListenerObject | null);
+    type: string;
+    callback: EventListener | null;
+    options: AddEventListenerOptions;
+    equals(executor: Executor): boolean;
+}
+declare const EventTargetE: {
+    new (): EventTarget;
+    prototype: EventTarget;
+};
+
+declare const state$6: unique symbol;
+declare class CustomEventP<T> extends EventP implements CustomEvent {
+    constructor(type: string, eventInitDict?: CustomEventInit<T>);
+    [state$6]: CustomEventState;
+    get detail(): T;
+    initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class CustomEventState {
+    detail: unknown;
+}
+declare const CustomEventE: {
+    new <T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
+    prototype: CustomEvent;
+};
+
+declare const state$5: unique symbol;
+declare class ProgressEventP extends EventP implements ProgressEvent {
+    constructor(type: string, eventInitDict?: ProgressEventInit);
+    [state$5]: ProgressEventState;
+    get lengthComputable(): boolean;
+    get loaded(): number;
+    get total(): number;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class ProgressEventState {
+    lengthComputable: boolean;
+    loaded: number;
+    total: number;
+}
+declare const ProgressEventE: {
+    new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
+    prototype: ProgressEvent;
+};
+
+declare class BlobP implements Blob {
+    constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
+    [state$8]: BlobState;
+    get size(): number;
+    get type(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<TUint8ArrayOfArrayBuffer>;
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    stream(): ReadableStream<TUint8ArrayOfArrayBuffer>;
+    text(): Promise<string>;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class BlobState {
+    constructor(buffer: TUint8ArrayOfArrayBuffer);
+    size: number;
+    type: string;
+    _u8array: TUint8ArrayOfArrayBuffer;
+}
+type TUint8ArrayOfArrayBuffer = ReturnType<TextEncoder["encode"]>;
+declare const BlobE: {
+    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+    prototype: Blob;
+};
+
+declare const state$4: unique symbol;
+declare class FileP extends BlobP implements File {
+    constructor(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag);
+    [state$4]: FileState;
+    get lastModified(): number;
+    get name(): string;
+    get webkitRelativePath(): string;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class FileState {
+    lastModified: number;
+    name: string;
+}
+declare const FileE: {
+    new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+    prototype: File;
+};
+
+declare const state$3: unique symbol;
+declare class FileReaderP extends EventTargetP implements FileReader {
+    static readonly EMPTY = 0;
+    static readonly LOADING = 1;
+    static readonly DONE = 2;
+    constructor();
+    [state$3]: FileReaderState;
+    get readyState(): 0 | 1 | 2;
+    get result(): string | ArrayBuffer | null;
+    readonly EMPTY = 0;
+    readonly LOADING = 1;
+    readonly DONE = 2;
+    get error(): DOMException | null;
+    abort(): void;
+    readAsArrayBuffer: (blob: Blob) => void;
+    readAsBinaryString: (blob: Blob) => void;
+    readAsDataURL: (blob: Blob) => void;
+    readAsText: (blob: Blob, encoding?: string) => void;
+    get onabort(): ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    set onabort(value: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null);
+    get onerror(): ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    set onerror(value: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null);
+    get onload(): ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    set onload(value: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null);
+    get onloadend(): ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    set onloadend(value: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null);
+    get onloadstart(): ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    set onloadstart(value: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null);
+    get onprogress(): ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    set onprogress(value: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null);
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class FileReaderState {
+    constructor(target: FileReaderP);
+    target: FileReaderP;
+    readyState: FileReader["readyState"];
+    result: string | ArrayBuffer | null;
+    error: DOMException | null;
+    read(kind: string, blob: Blob, setResult: () => void): void;
+    emitProcessEvent(type: string, loaded?: number, total?: number): void;
+    attach(type: keyof FileReaderEventMap): void;
+    onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    _onabort: (ev: ProgressEvent<FileReader>) => void;
+    onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    _onerror: (ev: ProgressEvent<FileReader>) => void;
+    onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    _onload: (ev: ProgressEvent<FileReader>) => void;
+    onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    _onloadend: (ev: ProgressEvent<FileReader>) => void;
+    onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    _onloadstart: (ev: ProgressEvent<FileReader>) => void;
+    onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    _onprogress: (ev: ProgressEvent<FileReader>) => void;
+}
+declare const FileReaderE: {
+    new (): FileReader;
+    prototype: FileReader;
+    readonly EMPTY: 0;
+    readonly LOADING: 1;
+    readonly DONE: 2;
+};
+
+declare class FormDataP implements FormData {
+    constructor(form?: HTMLFormElement, submitter?: HTMLElement | null);
+    [state$8]: FormDataState;
+    append(name: string, value: string | Blob, filename?: string): void;
+    delete(name: string): void;
+    get(name: string): FormDataEntryValue | null;
+    getAll(name: string): FormDataEntryValue[];
+    has(name: string): boolean;
+    set(name: string, value: string | Blob, filename?: string): void;
+    forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
+    entries(): ArrayIterator<[string, FormDataEntryValue]>;
+    keys(): ArrayIterator<string>;
+    values(): ArrayIterator<FormDataEntryValue>;
+    [Symbol.iterator](): ArrayIterator<[string, FormDataEntryValue]>;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class FormDataState {
+    _data: [string, FormDataEntryValue][];
+    toBlob(): BlobP;
+}
+declare const FormDataE: {
+    new (form?: HTMLFormElement, submitter?: HTMLElement | null): FormData;
+    prototype: FormData;
+};
+
+declare class URLSearchParamsP implements URLSearchParams {
+    constructor(init?: string[][] | Record<string, string> | string | URLSearchParams);
+    [state$8]: URLSearchParamsState;
+    get size(): number;
+    append(name: string, value: string): void;
+    delete(name: string, value?: string): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string, value?: string): boolean;
+    set(name: string, value: string): void;
+    sort(): void;
+    forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
+    entries(): ArrayIterator<[string, string]>;
+    keys(): ArrayIterator<string>;
+    values(): ArrayIterator<string>;
+    [Symbol.iterator](): ArrayIterator<[string, string]>;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class URLSearchParamsState {
+    _dict: Record<string, string[]>;
+}
+declare const URLSearchParamsE: {
+    new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    prototype: URLSearchParams;
+};
+
+declare class AbortSignalP extends EventTargetP implements AbortSignal {
+    static abort(reason?: any): AbortSignal;
+    static any(signals: AbortSignal[]): AbortSignal;
+    static timeout(milliseconds: number): AbortSignal;
+    constructor();
+    [state$8]: AbortSignalState;
+    get aborted(): boolean;
+    get reason(): any;
+    throwIfAborted(): void;
+    get onabort(): ((this: AbortSignal, ev: Event) => any) | null;
+    set onabort(value: ((this: AbortSignal, ev: Event) => any) | null);
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class AbortSignalState {
+    constructor(target: AbortSignalP);
+    target: AbortSignalP;
+    aborted: boolean;
+    reason: any;
+    abort(reason: any, notify?: boolean, isTrusted?: boolean): void;
+    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+    _onabort: (ev: Event) => void;
+}
+declare const AbortSignalE: {
+    new (): AbortSignal;
+    prototype: AbortSignal;
+    abort(reason?: any): AbortSignal;
+    any(signals: AbortSignal[]): AbortSignal;
+    timeout(milliseconds: number): AbortSignal;
+};
+
+declare const state$2: unique symbol;
+declare class AbortControllerP implements AbortController {
+    constructor();
+    [state$2]: AbortControllerState;
+    get signal(): AbortSignal;
+    abort(reason?: any): void;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class AbortControllerState {
+    signal: AbortSignalP;
+}
+declare const AbortControllerE: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+
+declare class XMLHttpRequestEventTargetP extends EventTargetP implements XMLHttpRequestEventTarget {
+    constructor();
+    [state$8]: XMLHttpRequestEventTargetState;
+    get onabort(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onabort(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onerror(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onerror(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onload(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onload(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onloadend(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onloadend(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onloadstart(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onloadstart(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onprogress(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onprogress(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get ontimeout(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set ontimeout(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class XMLHttpRequestEventTargetState {
+    /**
+     * @param _target XMLHttpRequestEventTargetP
+     */
+    constructor(_target: unknown);
+    target: XMLHttpRequest;
+    attach(type: keyof XMLHttpRequestEventTargetEventMap): void;
+    onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onabort: (ev: ProgressEvent) => void;
+    onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onerror: (ev: ProgressEvent) => void;
+    onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onload: (ev: ProgressEvent) => void;
+    onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onloadend: (ev: ProgressEvent) => void;
+    onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onloadstart: (ev: ProgressEvent) => void;
+    onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onprogress: (ev: ProgressEvent) => void;
+    ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _ontimeout: (ev: ProgressEvent) => void;
+}
+
+declare class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP implements XMLHttpRequestUpload {
+    constructor();
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+
+interface IGeneralCallbackResult {
+    /**
+     * 网络请求过程中的一些异常信息，例如httpdns超时等
+     */
+    exception: {
+        /**
+         * 本次请求底层重试次数
+         */
+        retryCount: number;
+        /**
+         * 本次请求底层失败信息，所有失败信息均符合Errno错误码
+         */
+        reasons: Array<{
+            /**
+             * 错误原因
+             */
+            errMsg: string;
+            /**
+             * 错误码
+             */
+            errno: number;
+        }>;
+    };
+    /**
+     * 最终请求是否使用了HttpDNS解析的IP。仅当enableHttpDNS传true时返回此字段。如果开启enableHttpDNS但最终请求未使用HttpDNS解析的IP，可在exception查看原因。
+     */
+    useHttpDNS: boolean;
+}
+interface IRequestSuccessCallbackBaseResult {
+    /**
+     * 开发者服务器返回的数据
+     */
+    data: string | object | ArrayBuffer;
+    /**
+     * 开发者服务器返回的 HTTP 状态码
+     */
+    statusCode: number;
+    /**
+     * 开发者服务器返回的 HTTP Response Header
+     */
+    header: object;
+}
+interface IRequestFailCallbackResult extends IGeneralCallbackResult {
+    /**
+     * 错误信息
+     */
+    errMsg: string;
+    /**
+     * errno 错误码
+     */
+    errno: number;
+}
+interface IAliRequestFailCallbackResult {
+    /**
+     * 错误码
+     */
+    error: number;
+    /**
+     * 错误信息
+     */
+    errorMessage: string;
+    /**
+     * 开发者服务器返回的数据，格式取决于请求时的 dataType 参数。
+     * 注意：当错误码为 14 或 19 时才会返回此字段
+     */
+    data?: string | object | ArrayBuffer;
+    /**
+     * 开发者服务器返回的 HTTP 状态码
+     * 注意：当错误码为 14 或 19 时才会返回此字段
+     */
+    status?: number;
+    /**
+     * 开发者服务器返回的 HTTP Response Header
+     * 注意：当错误码为 14 或 19 时才会返回此字段
+     */
+    headers?: object;
+}
+interface IRequestTask {
+    /**
+     * 中断请求任务
+     */
+    abort: () => void;
+    /**
+     * 监听 HTTP Response Header 事件。会比请求完成事件更早
+     */
+    onHeadersReceived: (listener: (res: {
+        /**
+         * 开发者服务器返回的 HTTP Response Header
+         */
+        header: object;
+        /**
+         * 开发者服务器返回的 HTTP 状态码 （目前开发者工具上不会返回 statusCode 字段，可用真机查看该字段，后续将会支持）
+         */
+        statusCode: number;
+        /**
+         * 开发者服务器返回的 cookies，格式为字符串数组
+         */
+        cookies: string[];
+    }) => void) => void;
+    /**
+     * 移除 HTTP Response Header 事件的监听函数
+     */
+    offHeadersReceived: (listener: Function) => void;
+    /**
+     * 监听 Transfer-Encoding Chunk Received 事件。当接收到新的chunk时触发。
+     */
+    onChunkReceived: (listener: (res: {
+        /**
+         * 返回的chunk buffer
+         */
+        data: ArrayBuffer;
+    }) => void) => void;
+    /**
+     * 移除 Transfer-Encoding Chunk Received 事件的监听函数
+     */
+    offChunkReceived: (listener: Function) => void;
+}
+
+declare const state$1: unique symbol;
+
+declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLHttpRequest {
+    static readonly UNSENT = 0;
+    static readonly OPENED = 1;
+    static readonly HEADERS_RECEIVED = 2;
+    static readonly LOADING = 3;
+    static readonly DONE = 4;
+    constructor();
+    [state$1]: XMLHttpRequestState;
+    readonly UNSENT = 0;
+    readonly OPENED = 1;
+    readonly HEADERS_RECEIVED = 2;
+    readonly LOADING = 3;
+    readonly DONE = 4;
+    get readyState(): number;
+    get response(): any;
+    get responseText(): string;
+    get responseType(): XMLHttpRequestResponseType;
+    set responseType(value: XMLHttpRequestResponseType);
+    get responseURL(): string;
+    get responseXML(): Document | null;
+    get status(): number;
+    get statusText(): string;
+    get timeout(): number;
+    set timeout(value: number);
+    get upload(): XMLHttpRequestUploadP;
+    get withCredentials(): boolean;
+    set withCredentials(value: boolean);
+    abort(): void;
+    getAllResponseHeaders(): string;
+    getResponseHeader(name: string): string | null;
+    open(...args: [method: string, url: string | URL, async?: boolean, username?: string | null, password?: string | null]): void;
+    overrideMimeType(mime: string): void;
+    send(body?: Document | XMLHttpRequestBodyInit | null): void;
+    setRequestHeader(name: string, value: string): void;
+    get onreadystatechange(): ((this: XMLHttpRequest, ev: Event) => any) | null;
+    set onreadystatechange(value: ((this: XMLHttpRequest, ev: Event) => any) | null);
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class XMLHttpRequestState {
+    constructor(target: XMLHttpRequestP);
+    target: XMLHttpRequestP;
+    readyState: number;
+    response: any;
+    responseType: XMLHttpRequestResponseType;
+    responseURL: string;
+    status: number;
+    statusText: string;
+    timeout: number;
+    upload: XMLHttpRequestUploadP;
+    withCredentials: boolean;
+    _reqCanSend: boolean;
+    _resetPending: boolean;
+    _timeoutId: number;
+    _reqURL: string;
+    _method: string;
+    _reqHeaders: Record<string, string>;
+    _resHeaders: Record<string, string> | null;
+    _resContLen: number;
+    _requestTask: IRequestTask | null;
+    execRequest(body?: Document | XMLHttpRequestBodyInit | null): void;
+    requestSuccess({ statusCode, header, data }: IRequestSuccessCallbackBaseResult): void;
+    requestFail(err: IRequestFailCallbackResult | IAliRequestFailCallbackResult): void;
+    requestComplete(): void;
+    clearRequest(delay?: boolean): void;
+    checkRequestTimeout(): void;
+    resetXHR(): void;
+    resetRequestTimeout(): void;
+    emitProcessEvent(type: string, loaded?: number, total?: number, target?: XMLHttpRequestEventTargetP): void;
+    setReadyStateAndNotify(value: number): void;
+    onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
+    _onreadystatechange: (ev: Event) => void;
+}
+declare const XMLHttpRequestE: {
+    new (): XMLHttpRequest;
+    prototype: XMLHttpRequest;
+    readonly UNSENT: 0;
+    readonly OPENED: 1;
+    readonly HEADERS_RECEIVED: 2;
+    readonly LOADING: 3;
+    readonly DONE: 4;
+} | typeof XMLHttpRequestP;
+
+declare function fetchP(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+declare const fetchE: typeof fetch;
+
+declare class HeadersP implements Headers {
+    constructor(init?: HeadersInit);
+    [state$8]: HeadersState;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    getSetCookie(): string[];
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+    entries(): MapIterator<[string, string]>;
+    keys(): ArrayIterator<string>;
+    values(): ArrayIterator<string>;
+    [Symbol.iterator](): MapIterator<[string, string]>;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class HeadersState {
+    _map: Map<string, [string, string]>;
+}
+declare const HeadersE: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+
+declare const state: unique symbol;
+
+declare class BodyP implements Body {
+    constructor();
+    [state]: BodyState;
+    get body(): ReadableStream<TUint8ArrayOfArrayBuffer> | null;
+    get bodyUsed(): boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<TUint8ArrayOfArrayBuffer>;
+    formData(): Promise<FormData>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class BodyState {
+    bodyUsed: boolean;
+    _name: string;
+    _body: string | ArrayBuffer;
+    init(body?: ConstructorParameters<typeof Response>[0], headers?: Headers): void;
+    read(k: "arrayBuffer"): Promise<ArrayBuffer>;
+    read(k: "blob"): Promise<Blob>;
+    read(k: "bytes"): Promise<TUint8ArrayOfArrayBuffer>;
+    read(k: "formData"): Promise<FormData>;
+    read(k: "json"): Promise<any>;
+    read(k: "text"): Promise<string>;
+    consumed(kind: string): Promise<never> | undefined;
+}
+
+declare class RequestP extends BodyP implements Request {
+    constructor(input: RequestInfo | URL, init?: RequestInit);
+    [state$8]: RequestState;
+    get cache(): RequestCache;
+    get credentials(): RequestCredentials;
+    get destination(): RequestDestination;
+    get headers(): Headers;
+    get integrity(): string;
+    get keepalive(): boolean;
+    get method(): string;
+    get mode(): RequestMode;
+    get redirect(): RequestRedirect;
+    get referrer(): string;
+    get referrerPolicy(): ReferrerPolicy;
+    get signal(): AbortSignal;
+    get url(): string;
+    clone(): Request;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class RequestState {
+    cache: RequestCache;
+    credentials: RequestCredentials;
+    destination: RequestDestination;
+    headers: Headers;
+    integrity: string;
+    keepalive: boolean;
+    method: string;
+    mode: RequestMode;
+    redirect: RequestRedirect;
+    referrer: string;
+    referrerPolicy: ReferrerPolicy;
+    signal: AbortSignal;
+    url: string;
+}
+declare const RequestE: {
+    new (input: RequestInfo | URL, init?: RequestInit): Request;
+    prototype: Request;
+};
+
+declare class ResponseP extends BodyP implements Response {
+    constructor(body?: BodyInit | null, init?: ResponseInit);
+    [state$8]: ResponseState;
+    get headers(): Headers;
+    get ok(): boolean;
+    get redirected(): boolean;
+    get status(): number;
+    get statusText(): string;
+    get type(): ResponseType;
+    get url(): string;
+    clone(): Response;
+    static json(data: any, init?: ResponseInit): Response;
+    static error(): ResponseP;
+    static redirect(url: string | URL, status?: number): Response;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class ResponseState {
+    headers: Headers;
+    ok: boolean;
+    redirected: boolean;
+    status: number;
+    statusText: string;
+    type: ResponseType;
+    url: string;
+}
+declare const ResponseE: {
+    new (body?: BodyInit | null, init?: ResponseInit): Response;
+    prototype: Response;
+    error(): Response;
+    json(data: any, init?: ResponseInit): Response;
+    redirect(url: string | URL, status?: number): Response;
+};
+
+export { AbortControllerE as AbortController, AbortControllerP, AbortSignalE as AbortSignal, AbortSignalP, BlobE as Blob, BlobP, CustomEventE as CustomEvent, CustomEventP, EventE as Event, EventP, EventTargetE as EventTarget, EventTargetP, FileE as File, FileP, FileReaderE as FileReader, FileReaderP, FormDataE as FormData, FormDataP, HeadersE as Headers, HeadersP, ProgressEventE as ProgressEvent, ProgressEventP, RequestE as Request, RequestP, ResponseE as Response, ResponseP, TextDecoderE as TextDecoder, TextDecoderP, TextEncoderE as TextEncoder, TextEncoderP, URLSearchParamsE as URLSearchParams, URLSearchParamsP, XMLHttpRequestE as XMLHttpRequest, XMLHttpRequestP, fetchE as fetch, fetchP };