@gjsify/fetch 0.0.4 → 0.1.1

package/lib/index.js

@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch) and the Fetch API spec (https://fetch.spec.whatwg.org/)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using libsoup 3.0 (Soup.Session)
+import Stream from 'node:stream';
+import { parseDataUri } from './utils/data-uri.js';
+import { clone } from './body.js';
+import Response from './response.js';
+import Headers from './headers.js';
+import Request, { getSoupRequestOptions } from './request.js';
+import { FetchError } from './errors/fetch-error.js';
+import { AbortError } from './errors/abort-error.js';
+import { isRedirect } from './utils/is-redirect.js';
+import { FormData } from '@gjsify/formdata';
+import { isDomainOrSubdomain, isSameProtocol } from './utils/is.js';
+import { parseReferrerPolicyFromHeader } from './utils/referrer.js';
+import { Blob, File, } from './utils/blob-from.js';
+import { URL } from '@gjsify/url';
+export { FormData, Headers, Request, Response, FetchError, AbortError, isRedirect };
+export { Blob, File };
+const supportedSchemas = new Set(['data:', 'http:', 'https:']);
+/**
+ * Fetch function
+ *
+ * @param url Absolute url or Request instance
+ * @param init Fetch options
+ */
+export default async function fetch(url, init = {}) {
+    // Build request object
+    const request = new Request(url, init);
+    const { parsedURL, options } = getSoupRequestOptions(request);
+    if (!supportedSchemas.has(parsedURL.protocol)) {
+        throw new TypeError(`@gjsify/fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, '')}" is not supported.`);
+    }
+    // Handle data: URIs
+    if (parsedURL.protocol === 'data:') {
+        const { buffer, typeFull } = parseDataUri(request.url);
+        const response = new Response(Buffer.from(buffer), { headers: { 'Content-Type': typeFull } });
+        return response;
+    }
+    const { signal } = request;
+    // Check if already aborted
+    if (signal && signal.aborted) {
+        throw new AbortError('The operation was aborted.');
+    }
+    // Send HTTP request via Soup
+    let readable;
+    let cancellable;
+    try {
+        const sendRes = await request._send(options);
+        readable = sendRes.readable;
+        cancellable = sendRes.cancellable;
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        throw new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err);
+    }
+    // Wire up abort signal to cancellable
+    const abortHandler = () => {
+        cancellable.cancel();
+    };
+    if (signal) {
+        signal.addEventListener('abort', abortHandler, { once: true });
+    }
+    const finalize = () => {
+        if (signal) {
+            signal.removeEventListener('abort', abortHandler);
+        }
+    };
+    // Listen for cancellation
+    cancellable.connect('cancelled', () => {
+        readable.destroy(new AbortError('The operation was aborted.'));
+    });
+    // Handle stream errors
+    readable.on('error', (error) => {
+        finalize();
+        // Error is consumed by the body when read
+    });
+    const message = request._message;
+    const headers = Headers._newFromSoupMessage(message);
+    const statusCode = message.status_code;
+    const statusMessage = message.get_reason_phrase();
+    // HTTP fetch step 5 — handle redirects
+    if (isRedirect(statusCode)) {
+        const location = headers.get('Location');
+        let locationURL = null;
+        try {
+            locationURL = location === null ? null : new URL(location, request.url);
+        }
+        catch {
+            if (request.redirect !== 'manual') {
+                finalize();
+                throw new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect');
+            }
+        }
+        switch (request.redirect) {
+            case 'error':
+                finalize();
+                throw new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect');
+            case 'manual':
+                // Nothing to do — return opaque redirect response
+                break;
+            case 'follow': {
+                if (locationURL === null) {
+                    break;
+                }
+                if (request.counter >= request.follow) {
+                    finalize();
+                    throw new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect');
+                }
+                const requestOptions = {
+                    headers: new Headers(request.headers),
+                    follow: request.follow,
+                    counter: request.counter + 1,
+                    agent: request.agent,
+                    compress: request.compress,
+                    method: request.method,
+                    body: clone(request),
+                    signal: request.signal,
+                    size: request.size,
+                    referrer: request.referrer,
+                    referrerPolicy: request.referrerPolicy
+                };
+                // Don't forward sensitive headers to different domains/protocols
+                if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
+                    for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
+                        requestOptions.headers.delete(name);
+                    }
+                }
+                // Cannot follow redirect with body being a readable stream
+                if (statusCode !== 303 && request.body && init.body instanceof Stream.Readable) {
+                    finalize();
+                    throw new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect');
+                }
+                // 303 or POST→GET conversion
+                if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && request.method === 'POST')) {
+                    requestOptions.method = 'GET';
+                    requestOptions.body = undefined;
+                    requestOptions.headers.delete('content-length');
+                }
+                // Update referrer policy from response
+                const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
+                if (responseReferrerPolicy) {
+                    requestOptions.referrerPolicy = responseReferrerPolicy;
+                }
+                finalize();
+                return fetch(new Request(locationURL, requestOptions));
+            }
+            default:
+                throw new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`);
+        }
+    }
+    // Build response
+    const responseOptions = {
+        url: request.url,
+        status: statusCode,
+        statusText: statusMessage,
+        headers,
+        size: request.size,
+        counter: request.counter,
+        highWaterMark: request.highWaterMark
+    };
+    // Handle content encoding (decompression)
+    const codings = headers.get('Content-Encoding');
+    // Skip decompression when:
+    // 1. compression support is disabled
+    // 2. HEAD request
+    // 3. no Content-Encoding header
+    // 4. no content response (204)
+    // 5. content not modified response (304)
+    if (!request.compress || request.method === 'HEAD' || codings === null || statusCode === 204 || statusCode === 304) {
+        finalize();
+        return new Response(readable, responseOptions);
+    }
+    // Try to use DecompressionStream Web API (available in modern SpiderMonkey)
+    if (typeof DecompressionStream !== 'undefined') {
+        let format = null;
+        if (codings === 'gzip' || codings === 'x-gzip') {
+            format = 'gzip';
+        }
+        else if (codings === 'deflate' || codings === 'x-deflate') {
+            format = 'deflate';
+        }
+        if (format) {
+            const webBody = new Response(readable, responseOptions).body;
+            if (webBody) {
+                const decompressed = webBody.pipeThrough(new DecompressionStream(format));
+                finalize();
+                return new Response(decompressed, responseOptions);
+            }
+        }
+    }
+    // Fallback: return the body as-is (no streaming decompression available)
+    finalize();
+    return new Response(readable, responseOptions);
+}
+// Register Fetch API globals on GJS (pattern: @gjsify/abort-controller, @gjsify/eventsource)
+// On Node.js, native globals are already fully functional — only overwrite on GJS.
+const _isGJS = typeof globalThis.imports !== 'undefined';
+if (_isGJS) {
+    globalThis.fetch = fetch;
+    globalThis.Headers = Headers;
+    globalThis.Request = Request;
+    globalThis.Response = Response;
+}

package/lib/request.d.ts

@@ -0,0 +1,101 @@
+import GLib from '@girs/glib-2.0';
+import Soup from '@girs/soup-3.0';
+import Gio from '@girs/gio-2.0';
+import { URL } from '@gjsify/url';
+import { Blob } from './utils/blob-from.js';
+import { Readable } from 'node:stream';
+import Headers from './headers.js';
+import Body from './body.js';
+import type { FormData } from '@gjsify/formdata';
+declare const INTERNALS: unique symbol;
+export interface Request extends globalThis.Request {
+}
+/** This Fetch API interface represents a resource request. */
+export declare class Request extends Body {
+    /** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
+    readonly cache: RequestCache;
+    /** Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. */
+    readonly credentials: RequestCredentials;
+    /** Returns the kind of resource requested by request, e.g., "document" or "script". */
+    readonly destination: RequestDestination;
+    /** Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header. */
+    get headers(): Headers;
+    /** Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] */
+    readonly integrity: string;
+    /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
+    readonly keepalive: boolean;
+    /** Returns request's HTTP method, which is "GET" by default. */
+    get method(): string;
+    /** Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs. */
+    readonly mode: RequestMode;
+    /** Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. */
+    get redirect(): RequestRedirect;
+    /**
+     * Returns the referrer of request.
+     * Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default.
+     * This is used during fetching to determine the value of the `Referer` header of the request being made.
+     * @see https://fetch.spec.whatwg.org/#dom-request-referrer
+     **/
+    get referrer(): string;
+    /** Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. */
+    get referrerPolicy(): ReferrerPolicy;
+    set referrerPolicy(referrerPolicy: ReferrerPolicy);
+    /** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
+    get signal(): AbortSignal;
+    /** Returns the URL of request as a string. */
+    get url(): string;
+    get _uri(): GLib.Uri;
+    get _session(): Soup.Session;
+    get _message(): Soup.Message;
+    get _inputStream(): Gio.InputStream;
+    get [Symbol.toStringTag](): string;
+    [INTERNALS]: {
+        method: string;
+        redirect: RequestRedirect;
+        headers: Headers;
+        parsedURL: URL;
+        signal: AbortSignal;
+        referrer: string | URL;
+        referrerPolicy: ReferrerPolicy;
+        session: Soup.Session | null;
+        message: Soup.Message | null;
+        inputStream?: Gio.InputStream;
+        readable?: Readable;
+    };
+    follow: number;
+    compress: boolean;
+    counter: number;
+    agent: string | ((url: URL) => string);
+    highWaterMark: number;
+    insecureHTTPParser: boolean;
+    constructor(input: RequestInfo | URL | Request, init?: RequestInit);
+    /**
+     * Send the request using Soup.
+     */
+    _send(options: {
+        headers: Headers;
+    }): Promise<{
+        inputStream: Gio.InputStream;
+        readable: Readable;
+        cancellable: Gio.Cancellable;
+    }>;
+    /**
+     * Clone this request
+     */
+    clone(): Request;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+export default Request;
+/**
+ * @param request
+ */
+export declare const getSoupRequestOptions: (request: Request) => {
+    parsedURL: URL;
+    options: {
+        headers: Headers;
+    };
+};

package/lib/request.js

@@ -0,0 +1,308 @@
+// SPDX-License-Identifier: MIT
+// Adapted from node-fetch (https://github.com/node-fetch/node-fetch/blob/main/src/request.js)
+// Copyright (c) node-fetch contributors. MIT license.
+// Modifications: Rewritten for GJS using Soup.Message and Gio
+import GLib from '@girs/glib-2.0';
+import Soup from '@girs/soup-3.0';
+import Gio from '@girs/gio-2.0';
+import { soupSendAsync, inputStreamToReadable } from './utils/soup-helpers.js';
+import { URL } from '@gjsify/url';
+import Headers from './headers.js';
+import Body, { clone, extractContentType, getTotalBytes } from './body.js';
+import { isAbortSignal } from './utils/is.js';
+import { validateReferrerPolicy, determineRequestsReferrer, DEFAULT_REFERRER_POLICY } from './utils/referrer.js';
+const INTERNALS = Symbol('Request internals');
+/**
+ * Check if `obj` is an instance of Request.
+ */
+const isRequest = (obj) => {
+    return (typeof obj === 'object' &&
+        typeof obj.url === 'string');
+};
+/** This Fetch API interface represents a resource request. */
+export class Request extends Body {
+    /** Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. */
+    cache;
+    /** Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. */
+    credentials;
+    /** Returns the kind of resource requested by request, e.g., "document" or "script". */
+    destination;
+    /** Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header. */
+    get headers() {
+        return this[INTERNALS].headers;
+    }
+    /** Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] */
+    integrity;
+    /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
+    keepalive;
+    /** Returns request's HTTP method, which is "GET" by default. */
+    get method() {
+        return this[INTERNALS].method;
+    }
+    /** Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs. */
+    mode;
+    /** Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. */
+    get redirect() {
+        return this[INTERNALS].redirect;
+    }
+    /**
+     * Returns the referrer of request.
+     * Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default.
+     * This is used during fetching to determine the value of the `Referer` header of the request being made.
+     * @see https://fetch.spec.whatwg.org/#dom-request-referrer
+     **/
+    get referrer() {
+        if (this[INTERNALS].referrer === 'no-referrer') {
+            return '';
+        }
+        if (this[INTERNALS].referrer === 'client') {
+            return 'about:client';
+        }
+        if (this[INTERNALS].referrer) {
+            return this[INTERNALS].referrer.toString();
+        }
+        return undefined;
+    }
+    /** Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer. */
+    get referrerPolicy() {
+        return this[INTERNALS].referrerPolicy;
+    }
+    set referrerPolicy(referrerPolicy) {
+        this[INTERNALS].referrerPolicy = validateReferrerPolicy(referrerPolicy);
+    }
+    /** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
+    get signal() {
+        return this[INTERNALS].signal;
+    }
+    /** Returns the URL of request as a string. */
+    get url() {
+        return this[INTERNALS].parsedURL.toString();
+    }
+    get _uri() {
+        return GLib.Uri.parse(this.url, GLib.UriFlags.NONE);
+    }
+    get _session() {
+        return this[INTERNALS].session;
+    }
+    get _message() {
+        return this[INTERNALS].message;
+    }
+    get _inputStream() {
+        return this[INTERNALS].inputStream;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Request';
+    }
+    [INTERNALS];
+    // Node-fetch-only options
+    follow;
+    compress = false;
+    counter = 0;
+    agent = '';
+    highWaterMark = 16384;
+    insecureHTTPParser = false;
+    constructor(input, init) {
+        const inputRL = input;
+        const initRL = (init || {});
+        let parsedURL;
+        let requestObj = {};
+        if (isRequest(input)) {
+            parsedURL = new URL(inputRL.url);
+            requestObj = inputRL;
+        }
+        else {
+            parsedURL = new URL(input);
+        }
+        if (parsedURL.username !== '' || parsedURL.password !== '') {
+            throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
+        }
+        let method = initRL.method || requestObj.method || 'GET';
+        if (/^(delete|get|head|options|post|put)$/i.test(method)) {
+            method = method.toUpperCase();
+        }
+        if ((init?.body != null || (isRequest(input) && inputRL.body !== null)) &&
+            (method === 'GET' || method === 'HEAD')) {
+            throw new TypeError('Request with GET/HEAD method cannot have body');
+        }
+        const inputBody = init?.body ? init.body : (isRequest(input) && inputRL.body !== null ? clone(input) : null);
+        super(inputBody, {
+            size: initRL.size || 0
+        });
+        const headers = new Headers((init?.headers || inputRL.headers || {}));
+        if (inputBody !== null && !headers.has('Content-Type')) {
+            const contentType = extractContentType(inputBody, this);
+            if (contentType) {
+                headers.set('Content-Type', contentType);
+            }
+        }
+        let signal = isRequest(input) ?
+            inputRL.signal :
+            null;
+        if (init && 'signal' in init) {
+            signal = init.signal;
+        }
+        if (signal != null && !isAbortSignal(signal)) {
+            throw new TypeError('Expected signal to be an instanceof AbortSignal or EventTarget');
+        }
+        // §5.4, Request constructor steps, step 15.1
+        let referrer = init?.referrer == null ? inputRL.referrer : init.referrer;
+        if (referrer === '') {
+            // §5.4, Request constructor steps, step 15.2
+            referrer = 'no-referrer';
+        }
+        else if (referrer) {
+            // §5.4, Request constructor steps, step 15.3.1, 15.3.2
+            const parsedReferrer = new URL(referrer);
+            // §5.4, Request constructor steps, step 15.3.3, 15.3.4
+            referrer = /^about:(\/\/)?client$/.test(parsedReferrer.toString()) ? 'client' : parsedReferrer;
+        }
+        else {
+            referrer = undefined;
+        }
+        // Only create Soup objects for HTTP/HTTPS — data: URIs etc. don't go through Soup
+        const scheme = parsedURL.protocol;
+        let session = null;
+        let message = null;
+        if (scheme === 'http:' || scheme === 'https:') {
+            session = new Soup.Session();
+            message = new Soup.Message({
+                method,
+                uri: GLib.Uri.parse(parsedURL.toString(), GLib.UriFlags.NONE),
+            });
+        }
+        this[INTERNALS] = {
+            method,
+            redirect: init?.redirect || inputRL.redirect || 'follow',
+            headers,
+            parsedURL,
+            signal,
+            referrer,
+            referrerPolicy: '',
+            session,
+            message,
+        };
+        // Node-fetch-only options
+        this.follow = initRL.follow === undefined ? (inputRL.follow === undefined ? 20 : inputRL.follow) : initRL.follow;
+        this.compress = initRL.compress === undefined ? (inputRL.compress === undefined ? true : inputRL.compress) : initRL.compress;
+        this.counter = initRL.counter || inputRL.counter || 0;
+        this.agent = initRL.agent || inputRL.agent;
+        this.highWaterMark = initRL.highWaterMark || inputRL.highWaterMark || 16384;
+        this.insecureHTTPParser = initRL.insecureHTTPParser || inputRL.insecureHTTPParser || false;
+        // §5.4, Request constructor steps, step 16.
+        // Default is empty string per https://fetch.spec.whatwg.org/#concept-request-referrer-policy
+        this.referrerPolicy = init?.referrerPolicy || inputRL.referrerPolicy || '';
+    }
+    /**
+     * Send the request using Soup.
+     */
+    async _send(options) {
+        const { session, message } = this[INTERNALS];
+        if (!session || !message) {
+            throw new Error('Cannot send request: no Soup session (non-HTTP URL?)');
+        }
+        options.headers._appendToSoupMessage(message);
+        const cancellable = new Gio.Cancellable();
+        this[INTERNALS].inputStream = await soupSendAsync(session, message, GLib.PRIORITY_DEFAULT, cancellable);
+        this[INTERNALS].readable = inputStreamToReadable(this[INTERNALS].inputStream);
+        return {
+            inputStream: this[INTERNALS].inputStream,
+            readable: this[INTERNALS].readable,
+            cancellable
+        };
+    }
+    /**
+     * Clone this request
+     */
+    clone() {
+        return new Request(this);
+    }
+    async arrayBuffer() {
+        return super.arrayBuffer();
+    }
+    async blob() {
+        return super.blob();
+    }
+    async formData() {
+        return super.formData();
+    }
+    async json() {
+        return super.json();
+    }
+    async text() {
+        return super.text();
+    }
+}
+Object.defineProperties(Request.prototype, {
+    method: { enumerable: true },
+    url: { enumerable: true },
+    headers: { enumerable: true },
+    redirect: { enumerable: true },
+    clone: { enumerable: true },
+    signal: { enumerable: true },
+    referrer: { enumerable: true },
+    referrerPolicy: { enumerable: true }
+});
+export default Request;
+/**
+ * @param request
+ */
+export const getSoupRequestOptions = (request) => {
+    const { parsedURL } = request[INTERNALS];
+    const headers = new Headers(request[INTERNALS].headers);
+    // Fetch step 1.3
+    if (!headers.has('Accept')) {
+        headers.set('Accept', '*/*');
+    }
+    // HTTP-network-or-cache fetch steps 2.4-2.7
+    let contentLengthValue = null;
+    if (request.body === null && /^(post|put)$/i.test(request.method)) {
+        contentLengthValue = '0';
+    }
+    if (request.body !== null) {
+        const totalBytes = getTotalBytes(request);
+        // Set Content-Length if totalBytes is a Number (that is not NaN)
+        if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
+            contentLengthValue = String(totalBytes);
+        }
+    }
+    if (contentLengthValue) {
+        headers.set('Content-Length', contentLengthValue);
+    }
+    // 4.1. Main fetch, step 2.6
+    if (request.referrerPolicy === '') {
+        request.referrerPolicy = DEFAULT_REFERRER_POLICY;
+    }
+    // 4.1. Main fetch, step 2.7
+    if (request.referrer && request.referrer !== 'no-referrer') {
+        request[INTERNALS].referrer = determineRequestsReferrer(request);
+    }
+    else {
+        request[INTERNALS].referrer = 'no-referrer';
+    }
+    // 4.5. HTTP-network-or-cache fetch, step 6.9
+    if (request[INTERNALS].referrer instanceof URL) {
+        headers.set('Referer', request.referrer);
+    }
+    // HTTP-network-or-cache fetch step 2.11
+    if (!headers.has('User-Agent')) {
+        headers.set('User-Agent', 'gjsify-fetch');
+    }
+    // HTTP-network-or-cache fetch step 2.15
+    if (request.compress && !headers.has('Accept-Encoding')) {
+        headers.set('Accept-Encoding', 'gzip, deflate, br');
+    }
+    let { agent } = request;
+    if (typeof agent === 'function') {
+        agent = agent(parsedURL);
+    }
+    if (!headers.has('Connection') && !agent) {
+        headers.set('Connection', 'close');
+    }
+    const options = {
+        headers,
+    };
+    return {
+        parsedURL,
+        options
+    };
+};

package/lib/response.d.ts

@@ -0,0 +1,73 @@
+import Gio from '@girs/gio-2.0';
+import Headers from './headers.js';
+import Body from './body.js';
+import { Blob } from './utils/blob-from.js';
+import type { Readable } from 'node:stream';
+declare const INTERNALS: unique symbol;
+interface ResponseOptions {
+    status?: number;
+    statusText?: string;
+    headers?: HeadersInit | Headers;
+    url?: string;
+    type?: ResponseType;
+    ok?: boolean;
+    redirected?: boolean;
+    size?: number;
+    counter?: number;
+    highWaterMark?: number;
+}
+/**
+ * Response class
+ *
+ * Ref: https://fetch.spec.whatwg.org/#response-class
+ *
+ * @param body Readable stream
+ * @param opts Response options
+ */
+export declare class Response extends Body {
+    [INTERNALS]: {
+        type: ResponseType;
+        url: string;
+        status: number;
+        statusText: string;
+        headers: Headers;
+        counter: number;
+        highWaterMark: number;
+    };
+    _inputStream: Gio.InputStream | null;
+    constructor(body?: BodyInit | Readable | Blob | Buffer | null, options?: ResponseOptions);
+    get type(): ResponseType;
+    get url(): string;
+    get status(): number;
+    /**
+     * Convenience property representing if the request ended normally
+     */
+    get ok(): boolean;
+    get redirected(): boolean;
+    get statusText(): string;
+    get headers(): Headers;
+    get highWaterMark(): number;
+    /**
+     * Clone this response
+     *
+     * @return  Response
+     */
+    clone(): Response;
+    /**
+     * @param url The URL that the new response is to originate from.
+     * @param status An optional status code for the response (e.g., 302.)
+     * @returns A Response object.
+     */
+    static redirect(url: string, status?: number): Response;
+    static error(): Response;
+    /**
+     * Create a Response with a JSON body.
+     * @param data The data to serialize as JSON.
+     * @param init Optional response init options.
+     * @returns A Response with the JSON body and appropriate content-type header.
+     */
+    static json(data: unknown, init?: ResponseOptions): Response;
+    get [Symbol.toStringTag](): string;
+    text(): Promise<string>;
+}
+export default Response;