@mycroblog/mykit 0.0.0-placeholder.0

package/dist/schema.gen.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export {};

package/dist/sse.d.ts

@@ -0,0 +1,13 @@
+/** One dispatched event: its type (`message` when the stream named none) and its data lines joined by LF. */
+export type ServerSentEvent = {
+    event: string;
+    data: string;
+};
+/** Parses an event stream that arrives in pieces; feed it text with `push`, then call `end`. */
+export declare class EventStreamParser {
+    #private;
+    /** Parses the next piece of text and returns the events it completed. */
+    push(text: string): ServerSentEvent[];
+    /** Ends the stream. An event that no blank line completed is discarded, as the standard says. */
+    end(): ServerSentEvent[];
+}

package/dist/sse.js

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+// The parser of a text/event-stream body, as the HTML Standard interprets one ("Server-sent events",
+// §9.2.6 Interpreting an event stream: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation).
+// The stream client (stream.ts) reads the body with fetch, since EventSource cannot send the Authorization
+// header, so it parses the body itself. The client API sends no `id` and no `retry`
+// (it does not resume with Last-Event-ID), so those fields are ignored like any unknown field.
+/** The end of a line: CRLF, LF or CR. */
+const lineEnd = /\r\n|\n|\r/;
+/** Parses an event stream that arrives in pieces; feed it text with `push`, then call `end`. */
+export class EventStreamParser {
+    #buffer = "";
+    #started = false;
+    #event = "";
+    #data = "";
+    /** Parses the next piece of text and returns the events it completed. */
+    push(text) {
+        let input = this.#buffer + text;
+        if (!this.#started && input.length > 0) {
+            this.#started = true;
+            // A leading byte order mark is not part of the stream.
+            if (input.startsWith(""))
+                input = input.slice(1);
+        }
+        const events = [];
+        for (;;) {
+            const match = lineEnd.exec(input);
+            if (match === null)
+                break;
+            // A CR at the very end may be the first half of a CRLF that the next piece completes.
+            if (match[0] === "\r" && match.index === input.length - 1)
+                break;
+            const event = this.#line(input.slice(0, match.index));
+            if (event !== null)
+                events.push(event);
+            input = input.slice(match.index + match[0].length);
+        }
+        this.#buffer = input;
+        return events;
+    }
+    /** Ends the stream. An event that no blank line completed is discarded, as the standard says. */
+    end() {
+        const events = this.#buffer.endsWith("\r") ? this.push("\n") : [];
+        this.#buffer = "";
+        this.#event = "";
+        this.#data = "";
+        return events;
+    }
+    /** Processes one line; a blank line dispatches the event collected so far. */
+    #line(line) {
+        if (line === "")
+            return this.#dispatch();
+        // A comment (": heartbeat").
+        if (line.startsWith(":"))
+            return null;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        if (field === "event")
+            this.#event = value;
+        else if (field === "data")
+            this.#data += `${value}\n`;
+        return null;
+    }
+    #dispatch() {
+        const data = this.#data;
+        const event = this.#event === "" ? "message" : this.#event;
+        this.#event = "";
+        this.#data = "";
+        // An event without data is not dispatched.
+        if (data === "")
+            return null;
+        return { event, data: data.slice(0, -1) };
+    }
+}

package/dist/stream.d.ts

@@ -0,0 +1,86 @@
+import { type ClientOptions } from "./client.js";
+import type { components } from "./schema.gen.js";
+import { type ServerSentEvent } from "./sse.js";
+type Status = components["schemas"]["Status"];
+type Notification = components["schemas"]["Notification"];
+type Announcement = components["schemas"]["Announcement"];
+/**
+ * An event of the stream, with its data parsed. `unknown` is an event that this version of the library does not know,
+ * which a newer server may send: `event` is its name (`message` when it has none) and `data` its data, unparsed.
+ */
+export type StreamEvent = {
+    type: "update";
+    status: Status;
+} | {
+    type: "notification";
+    notification: Notification;
+} | {
+    type: "announcement";
+    announcement: Announcement;
+} | {
+    type: "announcement_removed";
+    id: string;
+} | {
+    type: "unknown";
+    event: string;
+    data: string;
+};
+/** How long a stream may stay silent before the client drops it: two of the server's heartbeats, 30 seconds apart. */
+export declare const defaultHeartbeatTimeout = 60000;
+/** Configures runStream: the client's options (but its retry policy), and the stream's. */
+export type StreamOptions = Omit<ClientOptions, "retry"> & {
+    /** Ends the stream; runStream resolves once it aborts. */
+    signal: AbortSignal;
+    /**
+     * Called whenever a stream opens: `reconnected` is false for the first one and true for every later one. The server
+     * replays nothing, so after a reconnection read the home timeline and the notifications again for what happened
+     * while the stream was closed.
+     */
+    onOpen?: (reconnected: boolean) => void;
+    /** Receives the events in the order they arrive. */
+    onEvent: (event: StreamEvent) => void;
+    /**
+     * Receives every failure that the client recovers from by connecting again (a network error, a 429, a 5xx, a silent
+     * stream) and every event whose data it cannot read, which it skips.
+     */
+    onError?: (error: unknown) => void;
+    /**
+     * How long the server may send nothing, heartbeats included, before the client drops the stream and connects again,
+     * in milliseconds; defaultHeartbeatTimeout when absent.
+     */
+    heartbeatTimeout?: number;
+};
+/** The failure of a stream on which nothing arrived for the heartbeat timeout. */
+export declare class HeartbeatTimeoutError extends Error {
+    readonly name = "HeartbeatTimeoutError";
+    constructor(timeout: number);
+}
+/** The failure of a 2xx answer to GET /streaming that is no event stream, such as a page of a proxy. */
+export declare class NotEventStreamError extends Error {
+    readonly name = "NotEventStreamError";
+}
+/**
+ * The wait before the next connection: a second after a stream that ended normally, doubling with each failure in a
+ * row up to a minute, and spread over its upper half at random so that the clients a server restart disconnected do
+ * not all come back at once.
+ */
+export declare function streamDelay(failures: number): number;
+/**
+ * Reads GET /streaming until `signal` aborts. It sends the access token of the TokenSource and, after a 401, refreshes
+ * it once per connection. It never sends Last-Event-ID: the server does not resume a stream. Whenever the stream ends
+ * or fails, it connects again: after a 429 (too many streams) or a 503 it waits for Retry-After, and otherwise for an
+ * exponential backoff with jitter. A stream that is silent for the heartbeat timeout counts as failed.
+ *
+ * It resolves once `signal` aborts, and rejects without connecting again when the server refuses the request for good:
+ * a ProblemError of a 4xx other than 408 and 429, such as a 401 that a refresh did not cure or a 403 for a missing
+ * scope (read:statuses and read:notifications), or a failure of the TokenSource other than a network one, such as an
+ * OAuthError of a refresh token that was revoked.
+ */
+export declare function runStream(options: StreamOptions): Promise<void>;
+/**
+ * Types an event by its name: the data of `update`, `notification`, and `announcement` is the server's Status,
+ * Notification, and Announcement, and that of `announcement_removed` the announcement's ID. An unknown name is an
+ * `unknown` event. It throws for a known event whose data is no JSON object with an `id`.
+ */
+export declare function parseStreamEvent({ event, data }: ServerSentEvent): StreamEvent;
+export {};

package/dist/stream.js

@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: MIT
+// The client of GET /api/v1/streaming (streamEvents): the Server-Sent Events of the user's new home entries,
+// notifications, and announcements. It reads the body of fetch, since EventSource cannot send the Authorization header.
+import { apiBasePath, parseOrigin } from "./client.js";
+import { isAbort, OAuthError } from "./oauth.js";
+import { NetworkError, ProblemError, problemFromResponse } from "./problem.js";
+import { EventStreamParser } from "./sse.js";
+import { parseRetryAfter, sleepSignal } from "./transport.js";
+/** How long a stream may stay silent before the client drops it: two of the server's heartbeats, 30 seconds apart. */
+export const defaultHeartbeatTimeout = 60_000;
+/** The failure of a stream on which nothing arrived for the heartbeat timeout. */
+export class HeartbeatTimeoutError extends Error {
+    name = "HeartbeatTimeoutError";
+    constructor(timeout) {
+        super(`mykit: no heartbeat from the stream for ${String(timeout)} ms`);
+    }
+}
+/** The failure of a 2xx answer to GET /streaming that is no event stream, such as a page of a proxy. */
+export class NotEventStreamError extends Error {
+    name = "NotEventStreamError";
+}
+/** The wait after a stream that ended, before connecting again. */
+const baseDelay = 1_000;
+/** The longest wait between failed connections. */
+const maxDelay = 60_000;
+/**
+ * The wait before the next connection: a second after a stream that ended normally, doubling with each failure in a
+ * row up to a minute, and spread over its upper half at random so that the clients a server restart disconnected do
+ * not all come back at once.
+ */
+export function streamDelay(failures) {
+    const delay = Math.min(maxDelay, baseDelay * 2 ** Math.min(failures, 10));
+    return delay / 2 + Math.random() * (delay / 2);
+}
+/**
+ * Reads GET /streaming until `signal` aborts. It sends the access token of the TokenSource and, after a 401, refreshes
+ * it once per connection. It never sends Last-Event-ID: the server does not resume a stream. Whenever the stream ends
+ * or fails, it connects again: after a 429 (too many streams) or a 503 it waits for Retry-After, and otherwise for an
+ * exponential backoff with jitter. A stream that is silent for the heartbeat timeout counts as failed.
+ *
+ * It resolves once `signal` aborts, and rejects without connecting again when the server refuses the request for good:
+ * a ProblemError of a 4xx other than 408 and 429, such as a 401 that a refresh did not cure or a 403 for a missing
+ * scope (read:statuses and read:notifications), or a failure of the TokenSource other than a network one, such as an
+ * OAuthError of a refresh token that was revoked.
+ */
+export async function runStream(options) {
+    const url = `${parseOrigin(options.server)}${apiBasePath}/streaming`;
+    const fetch = options.fetch ?? ((request) => globalThis.fetch(request));
+    const sleep = options.sleep ?? sleepSignal;
+    const heartbeat = options.heartbeatTimeout ?? defaultHeartbeatTimeout;
+    const { signal } = options;
+    let opened = false;
+    let failures = 0;
+    // signal may abort while the stream is awaited, which narrowing cannot see.
+    const aborted = () => signal.aborted;
+    while (!aborted()) {
+        let wait = null;
+        try {
+            await connect(url, fetch, heartbeat, options, opened, () => {
+                opened = true;
+                failures = 0;
+            });
+        }
+        catch (error) {
+            if (aborted())
+                return;
+            if (!recoverable(error))
+                throw error;
+            options.onError?.(error);
+            failures++;
+            if (error instanceof ProblemError && (error.status === 429 || error.status === 503)) {
+                wait = parseRetryAfter(error.headers.get("Retry-After"), Date.now());
+            }
+        }
+        if (aborted())
+            return;
+        try {
+            await sleep(wait ?? streamDelay(failures), signal);
+        }
+        catch (error) {
+            if (aborted())
+                return;
+            throw error;
+        }
+    }
+}
+/** Whether connecting again may cure error: a failure of the network or of the server, a silent stream, a 408 or 429. */
+function recoverable(error) {
+    if (error instanceof ProblemError)
+        return error.status >= 500 || error.status === 408 || error.status === 429;
+    if (error instanceof OAuthError)
+        return error.status >= 500 || error.status === 429;
+    return error instanceof NetworkError || error instanceof HeartbeatTimeoutError || error instanceof NotEventStreamError;
+}
+/**
+ * Opens one stream and reads it to its end, calling onOpened once it opened. It resolves when the server ends the
+ * stream and rejects with the failure that ended it or kept it from opening.
+ */
+async function connect(url, fetch, heartbeat, options, reconnected, onOpened) {
+    // The watchdog covers the connection too: a server that never answers is as silent as one that stopped.
+    const silence = new AbortController();
+    let reader = null;
+    let timer;
+    const arm = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            silence.abort(new HeartbeatTimeoutError(heartbeat));
+        }, heartbeat);
+    };
+    const disarm = () => {
+        clearTimeout(timer);
+    };
+    const signal = AbortSignal.any([options.signal, silence.signal]);
+    // A body that the fetch does not tie to the signal stops here too.
+    const stop = () => void reader?.cancel().catch(() => undefined);
+    signal.addEventListener("abort", stop, { once: true });
+    const silent = (error) => (silence.signal.aborted ? silence.signal.reason : error);
+    arm();
+    try {
+        let response;
+        try {
+            response = await open(url, fetch, options, signal);
+        }
+        catch (error) {
+            throw silent(error);
+        }
+        const body = response.body;
+        disarm();
+        options.onOpen?.(reconnected);
+        onOpened();
+        arm();
+        if (body === null)
+            return;
+        reader = body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        const parser = new EventStreamParser();
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (options.signal.aborted)
+                    return;
+                if (silence.signal.aborted)
+                    throw silence.signal.reason;
+                if (done)
+                    break;
+                disarm();
+                dispatch(parser.push(decoder.decode(value, { stream: true })), options);
+                arm();
+            }
+            dispatch([...parser.push(decoder.decode()), ...parser.end()], options);
+            // The server ended the stream (its shutdown, a token that stopped being valid, a client that fell behind).
+        }
+        catch (error) {
+            if (options.signal.aborted)
+                throw error;
+            throw silent(isAbort(error) ? error : new NetworkError("GET", url, error));
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+        }
+    }
+    finally {
+        disarm();
+        signal.removeEventListener("abort", stop);
+    }
+}
+/** Sends GET /streaming with the access token, refreshing it once after a 401, and returns an event stream's answer. */
+async function open(url, fetch, options, signal) {
+    const { tokenSource } = options;
+    let renewed = null;
+    for (let refreshed = false;; refreshed = true) {
+        const headers = new Headers({ Accept: "text/event-stream", "Cache-Control": "no-cache" });
+        const language = typeof options.acceptLanguage === "function" ? options.acceptLanguage() : options.acceptLanguage;
+        if (language !== undefined && language !== null && language !== "")
+            headers.set("Accept-Language", language);
+        const token = renewed ?? (await tokenSource?.getAccessToken()) ?? null;
+        if (token !== null)
+            headers.set("Authorization", `Bearer ${token}`);
+        let response;
+        try {
+            response = await fetch(new Request(url, { headers, signal }));
+        }
+        catch (error) {
+            if (isAbort(error) || signal.aborted)
+                throw signal.aborted ? signal.reason : error;
+            throw new NetworkError("GET", url, error);
+        }
+        if (response.status === 401 && token !== null && !refreshed && tokenSource?.refresh !== undefined) {
+            renewed = await tokenSource.refresh(token);
+            if (renewed !== null) {
+                await response.body?.cancel().catch(() => undefined);
+                continue;
+            }
+        }
+        if (response.status >= 400)
+            throw await problemFromResponse(response);
+        if (!isEventStream(response)) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new NotEventStreamError(`mykit: GET ${url} answered ${response.headers.get("Content-Type") ?? "no content type"}, not an event stream`);
+        }
+        return response;
+    }
+}
+/** Whether `response` is an event stream. */
+function isEventStream(response) {
+    return response.headers.get("Content-Type")?.split(";")[0]?.trim().toLowerCase() === "text/event-stream";
+}
+/** Hands the events to onEvent, typed by their names; one whose data it cannot read goes to onError instead. */
+function dispatch(events, options) {
+    for (const e of events) {
+        let parsed;
+        try {
+            parsed = parseStreamEvent(e);
+        }
+        catch (error) {
+            options.onError?.(error);
+            continue;
+        }
+        options.onEvent(parsed);
+    }
+}
+/** The events of the spec, whose data is an object with an `id`. */
+const knownEvents = new Set(["update", "notification", "announcement", "announcement_removed"]);
+/**
+ * Types an event by its name: the data of `update`, `notification`, and `announcement` is the server's Status,
+ * Notification, and Announcement, and that of `announcement_removed` the announcement's ID. An unknown name is an
+ * `unknown` event. It throws for a known event whose data is no JSON object with an `id`.
+ */
+export function parseStreamEvent({ event, data }) {
+    if (!knownEvents.has(event))
+        return { type: "unknown", event, data };
+    let value;
+    try {
+        value = JSON.parse(data);
+    }
+    catch (error) {
+        throw new Error(`mykit: the data of a stream event "${event}" is no JSON`, { cause: error });
+    }
+    if (typeof value !== "object" || value === null || typeof value["id"] !== "string") {
+        throw new Error(`mykit: the data of a stream event "${event}" has no id`);
+    }
+    switch (event) {
+        case "update":
+            return { type: "update", status: value };
+        case "notification":
+            return { type: "notification", notification: value };
+        case "announcement":
+            return { type: "announcement", announcement: value };
+        default:
+            return { type: "announcement_removed", id: value.id };
+    }
+}

package/dist/token.d.ts

@@ -0,0 +1,56 @@
+import { type OAuthConfig } from "./oauth.js";
+/** An OAuth 2.0 access token and the refresh token that renews it. */
+export type Token = {
+    accessToken: string;
+    /**
+     * Renews the access token. The server rotates it on every use (RFC 9700 §4.14): the previous one stops working, so
+     * the new one must be saved.
+     */
+    refreshToken?: string;
+    /** When the access token expires, in milliseconds since the Unix epoch; absent means unknown. */
+    expiresAt?: number;
+    /** The space-separated scopes of the token. */
+    scope?: string;
+};
+/**
+ * Gives the access token of a request; null sends it without one. The library never stores tokens itself.
+ *
+ * `refresh`, when present, renews the token after the server refused it with a 401: the client calls it once per
+ * request, with the access token the server refused, and sends the request again with the new one. Null leaves the
+ * 401 as it is.
+ */
+export interface TokenSource {
+    getAccessToken(): Promise<string | null>;
+    refresh?(refused: string): Promise<string | null>;
+}
+/**
+ * A TokenSource of one access token that is never renewed, for tests and short tasks. Use a RefreshingTokenSource
+ * for anything that runs longer than the token lives (an hour).
+ */
+export declare function staticToken(accessToken: string): TokenSource;
+/** Receives the tokens of every renewal; it must save the rotated refresh token. */
+export type OnTokens = (token: Token) => void | Promise<void>;
+/**
+ * The TokenSource of a client that holds a refresh token: it renews the access token with the refresh_token grant
+ * when it expires or the server refuses it. Renewals are serialized, so that concurrent requests that meet a 401
+ * renew it once: a used refresh token sent again revokes the whole token family. Every renewal passes the new tokens
+ * to `onTokens`; when it throws, the new tokens are kept in the source and the request that needed them fails with
+ * its error.
+ */
+export declare class RefreshingTokenSource implements TokenSource {
+    #private;
+    /**
+     * Starts from `token` (from `exchange`, or saved before) and renews it through the token endpoint of `oauth`.
+     * `now` is for tests.
+     */
+    constructor(oauth: OAuthConfig, token: Token | null, onTokens?: OnTokens, now?: () => number);
+    /** The current tokens, or null before the first. */
+    get token(): Token | null;
+    /** The current access token, renewed first when it has expired. */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * Renews the token after the server refused `refused`. When another request renewed it since `refused` was handed
+     * out, it returns that token instead of renewing again.
+     */
+    refresh(refused: string): Promise<string | null>;
+}

package/dist/token.js

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+import { tokenRequest } from "./oauth.js";
+/** How long before its expiry a token counts as expired, so that it does not expire on the way. */
+const expirySkewMs = 30_000;
+/** Whether the access token is set and not about to expire at now. */
+function valid(token, now) {
+    return token !== null && token.accessToken !== "" && (token.expiresAt === undefined || now + expirySkewMs < token.expiresAt);
+}
+/**
+ * A TokenSource of one access token that is never renewed, for tests and short tasks. Use a RefreshingTokenSource
+ * for anything that runs longer than the token lives (an hour).
+ */
+export function staticToken(accessToken) {
+    return {
+        getAccessToken: () => Promise.resolve(accessToken),
+    };
+}
+/**
+ * The TokenSource of a client that holds a refresh token: it renews the access token with the refresh_token grant
+ * when it expires or the server refuses it. Renewals are serialized, so that concurrent requests that meet a 401
+ * renew it once: a used refresh token sent again revokes the whole token family. Every renewal passes the new tokens
+ * to `onTokens`; when it throws, the new tokens are kept in the source and the request that needed them fails with
+ * its error.
+ */
+export class RefreshingTokenSource {
+    #oauth;
+    #onTokens;
+    #now;
+    #token;
+    /** The renewal in flight, which the requests that need a token meanwhile wait for. */
+    #renewal = null;
+    /**
+     * Starts from `token` (from `exchange`, or saved before) and renews it through the token endpoint of `oauth`.
+     * `now` is for tests.
+     */
+    constructor(oauth, token, onTokens, now = Date.now) {
+        this.#oauth = oauth;
+        this.#token = token;
+        this.#onTokens = onTokens;
+        this.#now = now;
+    }
+    /** The current tokens, or null before the first. */
+    get token() {
+        return this.#token;
+    }
+    /** The current access token, renewed first when it has expired. */
+    async getAccessToken() {
+        if (this.#renewal !== null)
+            return (await this.#renewal).accessToken;
+        if (valid(this.#token, this.#now()))
+            return this.#token.accessToken;
+        return (await this.#renew()).accessToken;
+    }
+    /**
+     * Renews the token after the server refused `refused`. When another request renewed it since `refused` was handed
+     * out, it returns that token instead of renewing again.
+     */
+    async refresh(refused) {
+        if (this.#renewal !== null)
+            return (await this.#renewal).accessToken;
+        if (valid(this.#token, this.#now()) && this.#token.accessToken !== refused)
+            return this.#token.accessToken;
+        return (await this.#renew()).accessToken;
+    }
+    /** Runs the refresh_token grant, once for every caller that asks while it runs. */
+    #renew() {
+        this.#renewal ??= this.#grant().finally(() => {
+            this.#renewal = null;
+        });
+        return this.#renewal;
+    }
+    async #grant() {
+        const current = this.#token;
+        if (current?.refreshToken === undefined || current.refreshToken === "") {
+            throw new Error("mykit: the token has expired and there is no refresh token");
+        }
+        const token = await tokenRequest(this.#oauth, { grant_type: "refresh_token", refresh_token: current.refreshToken });
+        token.refreshToken ??= current.refreshToken;
+        this.#token = token;
+        await this.#onTokens?.(token);
+        return token;
+    }
+}

package/dist/transport.d.ts

@@ -0,0 +1,38 @@
+import type { TokenSource } from "./token.js";
+/**
+ * Decides how a request answered with 429 or 503 is sent again. Only requests that are safe to repeat are retried:
+ * GET, HEAD, and requests with an Idempotency-Key.
+ */
+export type RetryPolicy = {
+    /** Turns the retries off: the 429 or 503 becomes a ProblemError at once. */
+    disabled?: boolean;
+    /** How many times a request is sent again; 3 by default. */
+    maxRetries?: number;
+    /**
+     * The longest the client waits before a retry, in milliseconds; one minute by default. When Retry-After asks for
+     * longer, the answer becomes a ProblemError instead.
+     */
+    maxWait?: number;
+};
+/** Waits for ms milliseconds, or rejects with the reason of signal when it aborts first. */
+export type Sleep = (ms: number, signal: AbortSignal) => Promise<void>;
+export type TransportOptions = {
+    fetch: (input: Request) => Promise<Response>;
+    tokenSource: TokenSource | undefined;
+    retry: RetryPolicy | undefined;
+    sleep?: Sleep;
+};
+/**
+ * The fetch of the generated client. For each request it adds the access token; after a 401 it refreshes the token
+ * once and sends the request again; after a 429 or 503 it waits and retries the requests that are safe to repeat;
+ * and it turns a failure to get an answer into a NetworkError. Every middleware of the client sees only the last
+ * answer.
+ */
+export declare function createTransport({ fetch, tokenSource, retry, sleep }: TransportOptions): (request: Request) => Promise<Response>;
+/**
+ * Reads a Retry-After header, in seconds or an HTTP date, as the wait from now in milliseconds; null when it is absent
+ * or unreadable.
+ */
+export declare function parseRetryAfter(retryAfter: string | null, now: number): number | null;
+/** Waits for ms, or rejects with the reason of signal when it aborts first. */
+export declare function sleepSignal(ms: number, signal: AbortSignal): Promise<void>;