fetch-h 3.0.2

package/dist/lib/cookie-jar.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieJar = void 0;
+const tough_cookie_1 = require("tough-cookie");
+class CookieJar {
+    constructor(jar = new tough_cookie_1.CookieJar()) {
+        this._jar = jar;
+    }
+    reset(jar = new tough_cookie_1.CookieJar()) {
+        this._jar = jar;
+    }
+    setCookie(cookie, url) {
+        return new Promise((resolve, reject) => {
+            this._jar.setCookie(cookie, url, (err, cookie) => {
+                if (err)
+                    return reject(err);
+                resolve(cookie);
+            });
+        });
+    }
+    setCookies(cookies, url) {
+        return Promise.all(cookies.map(cookie => this.setCookie(cookie, url)));
+    }
+    getCookies(url) {
+        return new Promise((resolve, reject) => {
+            this._jar.getCookies(url, (err, cookies) => {
+                if (err)
+                    return reject(err);
+                resolve(cookies);
+            });
+        });
+    }
+}
+exports.CookieJar = CookieJar;
+//# sourceMappingURL=cookie-jar.js.map

package/dist/lib/core.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+import { AbortSignal } from "./abort";
+import { Headers, RawHeaders } from "./headers";
+export declare type Method = "ACL" | "BIND" | "CHECKOUT" | "CONNECT" | "COPY" | "DELETE" | "GET" | "HEAD" | "LINK" | "LOCK" | "M-SEARCH" | "MERGE" | "MKACTIVITY" | "MKCALENDAR" | "MKCOL" | "MOVE" | "NOTIFY" | "OPTIONS" | "PATCH" | "POST" | "PROPFIND" | "PROPPATCH" | "PURGE" | "PUT" | "REBIND" | "REPORT" | "SEARCH" | "SUBSCRIBE" | "TRACE" | "UNBIND" | "UNLINK" | "UNLOCK" | "UNSUBSCRIBE";
+export declare type StorageBodyTypes = Buffer | NodeJS.ReadableStream;
+export declare type BodyTypes = StorageBodyTypes | string;
+export declare type ModeTypes = "cors" | "no-cors" | "same-origin";
+export declare type CredentialsTypes = "omit" | "same-origin" | "include";
+export declare type CacheTypes = "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached";
+export declare type RedirectTypes = "follow" | "error" | "manual";
+export declare type SpecialReferrerTypes = "no-referrer" | "client";
+export declare type ReferrerTypes = SpecialReferrerTypes | string;
+export declare type ReferrerPolicyTypes = "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "unsafe-url";
+export declare type ResponseTypes = "basic" | "cors" | "error";
+export declare type HttpProtocols = "http1" | "http2";
+export declare type HttpVersion = 1 | 2;
+export interface IBody {
+    readonly bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<any>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+    readable(): Promise<NodeJS.ReadableStream>;
+}
+export interface RequestInitWithoutBody {
+    method: Method;
+    headers: RawHeaders | Headers;
+    mode: ModeTypes;
+    credentials: CredentialsTypes;
+    cache: CacheTypes;
+    redirect: RedirectTypes;
+    referrer: ReferrerTypes;
+    referrerPolicy: ReferrerPolicyTypes;
+    integrity: string;
+    allowForbiddenHeaders: boolean;
+}
+export interface RequestInit extends RequestInitWithoutBody {
+    body: BodyTypes | IBody;
+    json: any;
+}
+export interface RequestInitWithUrl extends RequestInit {
+    url: string;
+}
+export declare type OnTrailers = (headers: Headers) => void;
+export interface FetchInit extends RequestInit {
+    signal: AbortSignal;
+    timeout: number;
+    onTrailers: OnTrailers;
+}
+export interface ResponseInit {
+    status: number;
+    statusText: string;
+    headers: RawHeaders | Headers;
+    allowForbiddenHeaders: boolean;
+}
+export declare class FetchError extends Error {
+    constructor(message: string);
+}
+export declare class AbortError extends Error {
+    constructor(message: string);
+}
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+export declare class RetryError extends Error {
+    constructor(message: string);
+}
+export declare type DecodeFunction = (stream: NodeJS.ReadableStream) => NodeJS.ReadableStream;
+export interface Decoder {
+    name: string;
+    decode: DecodeFunction;
+}
+export declare type PerOrigin<T> = (origin: string) => T;
+export declare function getByOrigin<T>(val: T | PerOrigin<T>, origin: string): T;
+export declare function parsePerOrigin<T>(val: T | PerOrigin<T> | undefined, _default: T): T | PerOrigin<T>;
+export interface Http1Options {
+    keepAlive: boolean | PerOrigin<boolean>;
+    keepAliveMsecs: number | PerOrigin<number>;
+    maxSockets: number | PerOrigin<number>;
+    maxFreeSockets: number | PerOrigin<number>;
+    timeout: void | number | PerOrigin<void | number>;
+}

package/dist/lib/core.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePerOrigin = exports.getByOrigin = exports.RetryError = exports.TimeoutError = exports.AbortError = exports.FetchError = void 0;
+class FetchError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, FetchError.prototype);
+    }
+}
+exports.FetchError = FetchError;
+class AbortError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, AbortError.prototype);
+    }
+}
+exports.AbortError = AbortError;
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;
+class RetryError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, RetryError.prototype);
+    }
+}
+exports.RetryError = RetryError;
+function getByOrigin(val, origin) {
+    return typeof val === "function"
+        ? val(origin)
+        : val;
+}
+exports.getByOrigin = getByOrigin;
+function parsePerOrigin(val, _default) {
+    if (val == null) {
+        return _default;
+    }
+    if (typeof val === "function")
+        return (origin) => {
+            const ret = val(origin);
+            if (ret == null)
+                return _default;
+            return ret;
+        };
+    return val;
+}
+exports.parsePerOrigin = parsePerOrigin;
+//# sourceMappingURL=core.js.map

package/dist/lib/fetch-common.d.ts

@@ -0,0 +1,38 @@
+import { AbortError, Decoder, FetchInit, TimeoutError } from "./core";
+import { SimpleSession } from "./simple-session";
+import { RawHeaders } from "./headers";
+import { Request } from "./request";
+import { Response } from "./response";
+export interface FetchExtra {
+    redirected: Array<string>;
+    timeoutAt?: number;
+}
+export interface TimeoutInfo {
+    promise: Promise<Response>;
+    clear: () => void;
+}
+export declare function setupFetch(session: SimpleSession, request: Request, init: Partial<FetchInit> | undefined, extra: FetchExtra): Promise<{
+    cleanup: () => void;
+    contentDecoders: readonly Decoder[];
+    endStream: boolean;
+    headersToSend: RawHeaders;
+    integrity: string;
+    method: import("./core").Method;
+    onTrailers: import("./core").OnTrailers | undefined;
+    origin: string;
+    redirect: import("./core").RedirectTypes;
+    redirected: string[];
+    request: Request;
+    signal: import("./abort").AbortSignal | undefined;
+    signalPromise: Promise<Response> | null;
+    timeoutAt: number | undefined;
+    timeoutInfo: TimeoutInfo | null;
+    url: string;
+}>;
+export declare function handleSignalAndTimeout(signalPromise: Promise<Response> | null, timeoutInfo: TimeoutInfo | null, cleanup: () => void, fetcher: () => Promise<Response>, onError: () => void): Promise<any>;
+export declare function make100Error(): Error;
+export declare function makeAbortedError(): AbortError;
+export declare function makeTimeoutError(): TimeoutError;
+export declare function makeIllegalRedirectError(): Error;
+export declare function makeRedirectionError(location: string | null): Error;
+export declare function makeRedirectionMethodError(location: string | null, method: string): Error;

package/dist/lib/fetch-common.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRedirectionMethodError = exports.makeRedirectionError = exports.makeIllegalRedirectError = exports.makeTimeoutError = exports.makeAbortedError = exports.make100Error = exports.handleSignalAndTimeout = exports.setupFetch = void 0;
+const http2_1 = require("http2");
+const url_1 = require("url");
+const already_1 = require("already");
+const body_1 = require("./body");
+const core_1 = require("./core");
+const headers_1 = require("./headers");
+const utils_1 = require("./utils");
+const { 
+// Required for a request
+HTTP2_HEADER_METHOD, HTTP2_HEADER_SCHEME, HTTP2_HEADER_PATH, HTTP2_HEADER_AUTHORITY, 
+// Methods
+HTTP2_METHOD_GET, HTTP2_METHOD_HEAD, 
+// Requests
+HTTP2_HEADER_USER_AGENT, HTTP2_HEADER_ACCEPT, HTTP2_HEADER_COOKIE, HTTP2_HEADER_CONTENT_TYPE, HTTP2_HEADER_CONTENT_LENGTH, HTTP2_HEADER_ACCEPT_ENCODING, } = http2_1.constants;
+function ensureNotCircularRedirection(redirections) {
+    const urls = [...redirections];
+    const last = urls.pop();
+    for (let i = 0; i < urls.length; ++i)
+        if (urls[i] === last) {
+            const err = new Error("Redirection loop detected");
+            err.urls = urls.slice(i);
+            throw err;
+        }
+}
+const makeDefaultEncodings = (mul = 1) => (0, utils_1.hasBuiltinBrotli)()
+    ? [
+        { name: "br", score: 1.0 * mul },
+        { name: "gzip", score: 0.8 * mul },
+        { name: "deflate", score: 0.5 * mul },
+    ]
+    : [
+        { name: "gzip", score: 1.0 * mul },
+        { name: "deflate", score: 0.5 * mul },
+    ];
+const defaultEncodings = makeDefaultEncodings();
+const fallbackEncodings = makeDefaultEncodings(0.8);
+const stringifyEncoding = (acceptEncoding) => `${acceptEncoding.name};q=${acceptEncoding.score}`;
+const stringifyEncodings = (accepts) => accepts
+    .map(acceptEncoding => stringifyEncoding(acceptEncoding))
+    .join(", ");
+function getEncodings(contentDecoders) {
+    if (contentDecoders.length === 0)
+        return stringifyEncodings(defaultEncodings);
+    const makeScore = (index) => 1 - (index / (contentDecoders.length)) * 0.2;
+    return stringifyEncodings([
+        ...contentDecoders.map(({ name }, index) => ({ name, score: makeScore(index) })),
+        ...fallbackEncodings,
+    ]);
+}
+async function setupFetch(session, request, init = {}, extra) {
+    const { redirected } = extra;
+    ensureNotCircularRedirection(redirected);
+    const { url, method, redirect, integrity } = request;
+    const { signal, onTrailers } = init;
+    const { origin, protocol, host, pathname, search, hash, } = new url_1.URL(url);
+    const path = pathname + search + hash;
+    const endStream = method === HTTP2_METHOD_GET || method === HTTP2_METHOD_HEAD;
+    const headers = new headers_1.Headers(request.headers);
+    const cookies = (await session.cookieJar.getCookies(url))
+        .map(cookie => cookie.cookieString());
+    const contentDecoders = session.contentDecoders();
+    const acceptEncoding = getEncodings(contentDecoders);
+    if (headers.has(HTTP2_HEADER_COOKIE))
+        cookies.push(...(0, utils_1.arrayify)(headers.get(HTTP2_HEADER_COOKIE)));
+    if (!headers.has("host"))
+        headers.set("host", host);
+    const headersToSend = {
+        // Set required headers
+        ...(session.protocol === "http1" ? {} : {
+            [HTTP2_HEADER_METHOD]: method,
+            [HTTP2_HEADER_SCHEME]: protocol.replace(/:.*/, ""),
+            [HTTP2_HEADER_PATH]: path,
+        }),
+        // Set default headers
+        [HTTP2_HEADER_ACCEPT]: session.accept(),
+        [HTTP2_HEADER_USER_AGENT]: session.userAgent(),
+        [HTTP2_HEADER_ACCEPT_ENCODING]: acceptEncoding,
+    };
+    if (cookies.length > 0)
+        headersToSend[HTTP2_HEADER_COOKIE] = cookies.join("; ");
+    for (const [key, val] of headers.entries()) {
+        if (key === "host" && session.protocol === "http2")
+            // Convert to :authority like curl does:
+            // https://github.com/grantila/fetch-h2/issues/9
+            headersToSend[HTTP2_HEADER_AUTHORITY] = val;
+        else if (key !== HTTP2_HEADER_COOKIE)
+            headersToSend[key] = val;
+    }
+    const inspector = new body_1.BodyInspector(request);
+    if (!endStream &&
+        inspector.length != null &&
+        !request.headers.has(HTTP2_HEADER_CONTENT_LENGTH))
+        headersToSend[HTTP2_HEADER_CONTENT_LENGTH] = "" + inspector.length;
+    if (!endStream &&
+        !request.headers.has("content-type") &&
+        inspector.mime)
+        headersToSend[HTTP2_HEADER_CONTENT_TYPE] = inspector.mime;
+    function timeoutError() {
+        return new core_1.TimeoutError(`${method} ${url} timed out after ${init.timeout} ms`);
+    }
+    const timeoutAt = extra.timeoutAt || (("timeout" in init && typeof init.timeout === "number")
+        // Setting the timeoutAt here at first time allows async cookie
+        // jar to not take part of timeout for at least the first request
+        // (in a potential redirect chain)
+        ? Date.now() + init.timeout
+        : void 0);
+    function setupTimeout() {
+        if (!timeoutAt)
+            return null;
+        const now = Date.now();
+        if (now >= timeoutAt)
+            throw timeoutError();
+        let timerId;
+        return {
+            clear: () => {
+                if (timerId)
+                    clearTimeout(timerId);
+            },
+            promise: new Promise((_resolve, reject) => {
+                timerId = setTimeout(() => {
+                    timerId = null;
+                    reject(timeoutError());
+                }, timeoutAt - now);
+            }),
+        };
+    }
+    const timeoutInfo = setupTimeout();
+    function abortError() {
+        return new core_1.AbortError(`${method} ${url} aborted`);
+    }
+    if (signal && signal.aborted)
+        throw abortError();
+    let abortHandler;
+    const signalPromise = signal
+        ?
+            new Promise((_resolve, reject) => {
+                signal.once("abort", abortHandler = () => {
+                    reject(abortError());
+                });
+            })
+        : null;
+    function cleanup() {
+        var _a, _b;
+        (_a = timeoutInfo === null || timeoutInfo === void 0 ? void 0 : timeoutInfo.clear) === null || _a === void 0 ? void 0 : _a.call(timeoutInfo);
+        (_b = timeoutInfo === null || timeoutInfo === void 0 ? void 0 : timeoutInfo.promise) === null || _b === void 0 ? void 0 : _b.catch(_err => { });
+        if (signal && abortHandler)
+            signal.removeListener("abort", abortHandler);
+    }
+    return {
+        cleanup,
+        contentDecoders,
+        endStream,
+        headersToSend,
+        integrity,
+        method,
+        onTrailers,
+        origin,
+        redirect,
+        redirected,
+        request,
+        signal,
+        signalPromise,
+        timeoutAt,
+        timeoutInfo,
+        url,
+    };
+}
+exports.setupFetch = setupFetch;
+function handleSignalAndTimeout(signalPromise, timeoutInfo, cleanup, fetcher, onError) {
+    return Promise.race([
+        signalPromise,
+        (timeoutInfo && timeoutInfo.promise),
+        fetcher().catch((0, already_1.rethrow)(onError)),
+    ]
+        .filter(promise => promise))
+        .finally(cleanup);
+}
+exports.handleSignalAndTimeout = handleSignalAndTimeout;
+function make100Error() {
+    return new Error("Request failed with 100 continue. " +
+        "This can't happen unless a server failure");
+}
+exports.make100Error = make100Error;
+function makeAbortedError() {
+    return new core_1.AbortError("Request aborted");
+}
+exports.makeAbortedError = makeAbortedError;
+function makeTimeoutError() {
+    return new core_1.TimeoutError("Request timed out");
+}
+exports.makeTimeoutError = makeTimeoutError;
+function makeIllegalRedirectError() {
+    return new Error("Server responded illegally with a " +
+        "redirect code but missing 'location' header");
+}
+exports.makeIllegalRedirectError = makeIllegalRedirectError;
+function makeRedirectionError(location) {
+    return new Error(`URL got redirected to ${location}`);
+}
+exports.makeRedirectionError = makeRedirectionError;
+function makeRedirectionMethodError(location, method) {
+    return new Error(`URL got redirected to ${location}, which ` +
+        `'fetch-h2' doesn't support for ${method}`);
+}
+exports.makeRedirectionMethodError = makeRedirectionMethodError;
+//# sourceMappingURL=fetch-common.js.map

package/dist/lib/fetch-http1.d.ts

@@ -0,0 +1,7 @@
+import { FetchInit } from "./core";
+import { SimpleSessionHttp1 } from "./simple-session";
+import { FetchExtra } from "./fetch-common";
+import { Request } from "./request";
+import { Response } from "./response";
+export declare function fetchImpl(session: SimpleSessionHttp1, input: Request, init: Partial<FetchInit> | undefined, extra: FetchExtra): Promise<Response>;
+export declare function fetch(session: SimpleSessionHttp1, input: Request, init?: Partial<FetchInit>, extra?: FetchExtra): Promise<Response>;

package/dist/lib/fetch-http1.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = exports.fetchImpl = void 0;
+const http2_1 = require("http2");
+const callguard_1 = require("callguard");
+const abort_1 = require("./abort");
+const fetch_common_1 = require("./fetch-common");
+const headers_1 = require("./headers");
+const response_1 = require("./response");
+const utils_1 = require("./utils");
+const { 
+// Responses, these are the same in HTTP/1.1 and HTTP/2
+HTTP2_HEADER_LOCATION: HTTP1_HEADER_LOCATION, HTTP2_HEADER_SET_COOKIE: HTTP1_HEADER_SET_COOKIE, } = http2_1.constants;
+async function fetchImpl(session, input, init = {}, extra) {
+    const { cleanup, contentDecoders, endStream, headersToSend, integrity, method, onTrailers, redirect, redirected, request, signal, signalPromise, timeoutAt, timeoutInfo, url, } = await (0, fetch_common_1.setupFetch)(session, input, init, extra);
+    const { req, cleanup: socketCleanup } = session.get(url);
+    const doFetch = async () => {
+        for (const [key, value] of Object.entries(headersToSend)) {
+            if (value != null)
+                req.setHeader(key, value);
+        }
+        const response = new Promise((resolve, reject) => {
+            const guard = (0, callguard_1.syncGuard)(reject, { catchAsync: true });
+            req.once("error", reject);
+            req.once("aborted", guard(() => {
+                reject((0, fetch_common_1.makeAbortedError)());
+            }));
+            req.once("continue", guard(() => {
+                reject((0, fetch_common_1.make100Error)());
+            }));
+            req.once("information", guard((res) => {
+                resolve(new response_1.Response(null, // No body
+                { status: res.statusCode }));
+            }));
+            req.once("timeout", guard(() => {
+                reject((0, fetch_common_1.makeTimeoutError)());
+                req.abort();
+            }));
+            req.once("upgrade", guard((_res, _socket, _upgradeHead) => {
+                reject(new Error("Upgrade not implemented!"));
+                req.abort();
+            }));
+            req.once("response", guard((res) => {
+                res.once("end", socketCleanup);
+                const { signal: bodySignal = void 0, abort: bodyAbort = void 0, } = signal ? new abort_1.AbortController() : {};
+                if (signal) {
+                    const abortHandler = () => {
+                        bodyAbort();
+                        req.abort();
+                        res.destroy();
+                    };
+                    if (signal.aborted) {
+                        // No reason to continue, the request is aborted
+                        abortHandler();
+                        return;
+                    }
+                    signal.once("abort", abortHandler);
+                    res.once("end", () => {
+                        signal.removeListener("abort", abortHandler);
+                    });
+                }
+                const { headers, statusCode } = res;
+                res.once("end", guard(() => {
+                    if (!onTrailers)
+                        return;
+                    try {
+                        const { trailers } = res;
+                        const headers = new headers_1.GuardedHeaders("response");
+                        Object.keys(trailers).forEach(key => {
+                            if (trailers[key] != null)
+                                headers.set(key, "" + trailers[key]);
+                        });
+                        onTrailers(headers);
+                    }
+                    catch (err) {
+                        // TODO: Implement #8
+                        // tslint:disable-next-line
+                        console.warn("Trailer handling failed", err);
+                    }
+                }));
+                const location = (0, utils_1.parseLocation)(headers[HTTP1_HEADER_LOCATION], url);
+                const isRedirected = utils_1.isRedirectStatus["" + statusCode];
+                if (headers[HTTP1_HEADER_SET_COOKIE]) {
+                    const setCookies = (0, utils_1.arrayify)(headers[HTTP1_HEADER_SET_COOKIE]);
+                    session.cookieJar.setCookies(setCookies, url);
+                }
+                if (!input.allowForbiddenHeaders) {
+                    delete headers["set-cookie"];
+                    delete headers["set-cookie2"];
+                }
+                if (isRedirected && !location)
+                    return reject((0, fetch_common_1.makeIllegalRedirectError)());
+                if (!isRedirected || redirect === "manual")
+                    return resolve(new response_1.StreamResponse(contentDecoders, url, res, headers, redirect === "manual"
+                        ? false
+                        : extra.redirected.length > 0, {
+                        status: res.statusCode,
+                        statusText: res.statusMessage,
+                    }, bodySignal, 1, input.allowForbiddenHeaders, integrity));
+                const { url: locationUrl, isRelative } = location;
+                if (redirect === "error")
+                    return reject((0, fetch_common_1.makeRedirectionError)(locationUrl));
+                // redirect is 'follow'
+                // We don't support re-sending a non-GET/HEAD request (as
+                // we don't want to [can't, if its' streamed] re-send the
+                // body). The concept is fundementally broken anyway...
+                if (!endStream)
+                    return reject((0, fetch_common_1.makeRedirectionMethodError)(locationUrl, method));
+                res.destroy();
+                if (isRelative) {
+                    resolve(fetchImpl(session, request.clone(locationUrl), { signal, onTrailers }, {
+                        redirected: redirected.concat(url),
+                        timeoutAt,
+                    }));
+                }
+                else {
+                    resolve(session.newFetch(request.clone(locationUrl), init, {
+                        timeoutAt,
+                        redirected: redirected.concat(url),
+                    }));
+                }
+            }));
+        });
+        if (endStream)
+            req.end();
+        else
+            await request.readable()
+                .then(readable => {
+                (0, utils_1.pipeline)(readable, req)
+                    .catch(_err => {
+                    // TODO: Implement error handling
+                });
+            });
+        return response;
+    };
+    return (0, fetch_common_1.handleSignalAndTimeout)(signalPromise, timeoutInfo, cleanup, doFetch, socketCleanup);
+}
+exports.fetchImpl = fetchImpl;
+function fetch(session, input, init, extra) {
+    var _a;
+    extra = {
+        timeoutAt: extra === null || extra === void 0 ? void 0 : extra.timeoutAt,
+        redirected: (_a = extra === null || extra === void 0 ? void 0 : extra.redirected) !== null && _a !== void 0 ? _a : [],
+    };
+    return fetchImpl(session, input, init, extra);
+}
+exports.fetch = fetch;
+//# sourceMappingURL=fetch-http1.js.map

package/dist/lib/fetch-http2.d.ts

@@ -0,0 +1,6 @@
+import { FetchInit } from "./core";
+import { SimpleSessionHttp2 } from "./simple-session";
+import { FetchExtra } from "./fetch-common";
+import { Request } from "./request";
+import { Response } from "./response";
+export declare function fetch(session: SimpleSessionHttp2, input: Request, init?: Partial<FetchInit>, extra?: FetchExtra): Promise<Response>;