typedrest 0.5.0 → 0.6.0

package/endpoints/reactive/{StreamingEndpoint.ts → StreamingEndpoint.d.ts}

@@ -1,21 +1,17 @@
 import { Endpoint } from "../Endpoint";
-import { HttpMethod, entityStream } from "../../http";
-
 /**
  * Endpoint for a stream of `TEntity`s using a persistent HTTP connection.
  * @typeParam TEntity The type of individual elements in the stream.
  */
-export class StreamingEndpoint<TEntity> extends Endpoint {
+export declare class StreamingEndpoint<TEntity> extends Endpoint {
+    private readonly separator;
     /**
      * Creates a new streaming endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      * @param separator The character sequence used to detect that a new element starts in the HTTP stream.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string, private readonly separator: string = "\n") {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string, separator?: string);
     /**
      * Provides a stream of `TEntity`s, keeping the HTTP connection open until the server closes it.
      * @param signal Used to close the connection.
@@ -24,27 +20,9 @@ export class StreamingEndpoint<TEntity> extends Endpoint {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async *stream(signal?: AbortSignal): AsyncIterableIterator<TEntity> {
-        // NOTE: Abort the request when the consumer stops iterating, not just when the caller's signal fires.
-        const controller = new AbortController();
-        const onAbort = () => controller.abort();
-        signal?.addEventListener("abort", onAbort, { once: true });
-        if (signal?.aborted) controller.abort();
-
-        try {
-            const response = await this.send(HttpMethod.Get, controller.signal);
-            yield* entityStream<TEntity>(response, this.serializer, this.separator);
-        } catch (err) {
-            // Aborting is a regular way of ending the stream, not an error
-            if (!signal?.aborted) throw err;
-        } finally {
-            signal?.removeEventListener("abort", onAbort);
-            controller.abort();
-        }
-    }
-
+    stream(signal?: AbortSignal): AsyncIterableIterator<TEntity>;
     /**
      * Provides a stream of `TEntity`s using {@link stream}.
      */
-    [Symbol.asyncIterator]() { return this.stream(); }
+    [Symbol.asyncIterator](): AsyncIterableIterator<TEntity>;
 }

package/endpoints/rpc/{ActionEndpoint.ts → ActionEndpoint.d.ts}

@@ -1,20 +1,15 @@
 import { RpcEndpointBase } from "./RpcEndpointBase";
 import { Endpoint } from "../Endpoint";
-import { HttpMethod } from "../../http";
-
 /**
  * RPC endpoint that is invoked with no input or output.
  */
-export class ActionEndpoint extends RpcEndpointBase {
+export declare class ActionEndpoint extends RpcEndpointBase {
     /**
      * Creates a new action endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string) {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string);
     /**
      * Invokes the action.
      * @param signal Used to cancel the request.
@@ -23,7 +18,5 @@ export class ActionEndpoint extends RpcEndpointBase {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async invoke(signal?: AbortSignal) {
-        await this.send(HttpMethod.Post, signal);
-    }
+    invoke(signal?: AbortSignal): Promise<void>;
 }

package/endpoints/rpc/{ConsumerEndpoint.ts → ConsumerEndpoint.d.ts}

@@ -1,21 +1,16 @@
 import { RpcEndpointBase } from "./RpcEndpointBase";
 import { Endpoint } from "../Endpoint";
-import { HttpMethod, HttpHeader } from "../../http";
-
 /**
  * RPC endpoint that takes `TEntity` as input when invoked.
  * @typeParam TEntity The type of entity the endpoint takes as input.
  */
-export class ConsumerEndpoint<TEntity> extends RpcEndpointBase {
+export declare class ConsumerEndpoint<TEntity> extends RpcEndpointBase {
     /**
      * Creates a new consumer endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string) {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string);
     /**
      * Sends the entity to the consumer.
      * @param entity The `TEntity` to post as input.
@@ -25,9 +20,5 @@ export class ConsumerEndpoint<TEntity> extends RpcEndpointBase {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async invoke(entity: TEntity, signal?: AbortSignal) {
-        await this.send(HttpMethod.Post, signal, {
-            [HttpHeader.ContentType]: this.serializer.supportedMediaTypes[0]
-        }, this.serializer.serialize(entity));
-    }
+    invoke(entity: TEntity, signal?: AbortSignal): Promise<void>;
 }

package/endpoints/rpc/{FunctionEndpoint.ts → FunctionEndpoint.d.ts}

@@ -1,22 +1,17 @@
 import { RpcEndpointBase } from "./RpcEndpointBase";
 import { Endpoint } from "../Endpoint";
-import { HttpMethod, HttpHeader } from "../../http";
-
 /**
  * RPC endpoint that takes `TEntity` as input and returns `TResult` as output when invoked.
  * @typeParam TEntity The type of entity the endpoint takes as input.
  * @typeParam TResult The type of entity the endpoint returns as output.
  */
-export class FunctionEndpoint<TEntity, TResult> extends RpcEndpointBase {
+export declare class FunctionEndpoint<TEntity, TResult> extends RpcEndpointBase {
     /**
      * Creates a new function endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string) {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string);
     /**
      * Invokes the function.
      * @param entity The `TEntity` to post as input.
@@ -27,11 +22,5 @@ export class FunctionEndpoint<TEntity, TResult> extends RpcEndpointBase {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async invoke(entity: TEntity, signal?: AbortSignal): Promise<TResult> {
-        const response = await this.send(HttpMethod.Post, signal, {
-            [HttpHeader.ContentType]: this.serializer.supportedMediaTypes[0]
-        }, this.serializer.serialize(entity));
-
-        return this.serializer.deserialize<TResult>(await response.text());
-    }
+    invoke(entity: TEntity, signal?: AbortSignal): Promise<TResult>;
 }

package/endpoints/rpc/{ProducerEndpoint.ts → ProducerEndpoint.d.ts}

@@ -1,21 +1,16 @@
 import { RpcEndpointBase } from "./RpcEndpointBase";
 import { Endpoint } from "../Endpoint";
-import { HttpMethod } from "../../http";
-
 /**
  * RPC endpoint that returns `TResult` as output when invoked.
  * @typeParam TResult The type of entity the endpoint returns as output.
  */
-export class ProducerEndpoint<TResult> extends RpcEndpointBase {
+export declare class ProducerEndpoint<TResult> extends RpcEndpointBase {
     /**
      * Creates a new producer endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string) {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string);
     /**
      * Gets a result from the producer.
      * @param signal Used to cancel the request.
@@ -25,8 +20,5 @@ export class ProducerEndpoint<TResult> extends RpcEndpointBase {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async invoke(signal?: AbortSignal): Promise<TResult> {
-        const response = await this.send(HttpMethod.Post, signal);
-        return this.serializer.deserialize<TResult>(await response.text());
-    }
+    invoke(signal?: AbortSignal): Promise<TResult>;
 }

package/endpoints/rpc/{RpcEndpointBase.ts → RpcEndpointBase.d.ts}

@@ -1,19 +1,14 @@
 import { Endpoint } from "../Endpoint";
-import { HttpMethod } from "../../http";
-
 /**
  * Base class for building RPC endpoints.
  */
-export class RpcEndpointBase extends Endpoint {
+export declare class RpcEndpointBase extends Endpoint {
     /**
      * Creates a new RPC endpoint.
      * @param referrer The endpoint used to navigate to this one.
      * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
      */
-    constructor(referrer: Endpoint, relativeUri: URL | string) {
-        super(referrer, relativeUri);
-    }
-
+    constructor(referrer: Endpoint, relativeUri: URL | string);
     /**
      * Queries the server about capabilities of the endpoint without performing any action.
      * @param signal Used to cancel the request.
@@ -22,14 +17,11 @@ export class RpcEndpointBase extends Endpoint {
      * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
      * @throws {@link errors!HttpError}: Other non-success status code
      */
-    async probe(signal?: AbortSignal) {
-        await this.send(HttpMethod.Options, signal);
-    }
-
+    probe(signal?: AbortSignal): Promise<void>;
     /**
      * Shows whether the server has indicated that the invoke method is currently allowed.
      * Uses cached data from last response.
      * @returns `true` if the method is allowed, `false` if the method is not allowed, `undefined` if no request has been sent yet or the server did not specify allowed methods.
      */
-    get invokeAllowed() { return this.isMethodAllowed(HttpMethod.Post); }
+    get invokeAllowed(): boolean | undefined;
 }

package/errors/DefaultErrorHandler.d.ts

@@ -0,0 +1,21 @@
+import { ErrorHandler } from "./ErrorHandler";
+/**
+ * Handles errors in HTTP responses by mapping status codes to common error types.
+ */
+export declare class DefaultErrorHandler implements ErrorHandler {
+    /**
+     * Throws appropriate `Error`s based on HTTP status codes and response bodies.
+     *
+     * @throws {@link errors!BadRequestError}: {@link http!HttpStatusCode.BadRequest}
+     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
+     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
+     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
+     * @throws {@link errors!TimeoutError}: {@link http!HttpStatusCode.RequestTimeout}
+     * @throws {@link errors!ConflictError}: {@link http!HttpStatusCode.Conflict}
+     * @throws {@link errors!ConcurrencyError}: {@link http!HttpStatusCode.PreconditionFailed}
+     * @throws {@link errors!RangeNotSatisfiableError}: {@link http!HttpStatusCode.RangeNotSatisfiable}
+     * @throws {@link errors!HttpError}: Other non-success status code
+     */
+    handle(response: Response): Promise<void>;
+    private static errorType;
+}

package/errors/{Errors.ts → Errors.d.ts}

@@ -1,56 +1,55 @@
 import { HttpStatusCode } from "../http";
-
 /**
  * Thrown on HTTP response with a non-successful status code (4xx or 5xx).
  */
-export class HttpError extends Error {
+export declare class HttpError extends Error {
+    status: HttpStatusCode;
+    data?: any | undefined;
     /**
      * Creates a new HTTP error.
      * @param message The error message.
      * @param status The HTTP status code.
      * @param data Additional error data.
      */
-    constructor(message: string, public status: HttpStatusCode, public data?: any) {
-        super(message);
-    }
+    constructor(message: string, status: HttpStatusCode, data?: any | undefined);
 }
-
 /**
  * Thrown on HTTP response for a bad request (usually {@link http!HttpStatusCode.BadRequest}).
  */
-export class BadRequestError extends HttpError {}
-
+export declare class BadRequestError extends HttpError {
+}
 /**
  * Thrown on HTTP response for an unauthenticated request, i.e. missing credentials (usually {@link http!HttpStatusCode.Unauthorized}).
  */
-export class AuthenticationError extends HttpError {}
-
+export declare class AuthenticationError extends HttpError {
+}
 /**
  * Thrown on HTTP response for an unauthorized request, i.e. missing permissions (usually {@link http!HttpStatusCode.Forbidden}).
  */
-export class AuthorizationError extends HttpError {}
-
+export declare class AuthorizationError extends HttpError {
+}
 /**
  * Thrown on HTTP response for a missing resource (usually {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}).
  */
-export class NotFoundError extends HttpError {}
-
+export declare class NotFoundError extends HttpError {
+}
 /**
  * Thrown on HTTP response for a timed-out operation (usually {@link http!HttpStatusCode.RequestTimeout}).
  */
-export class TimeoutError extends HttpError {}
-
+export declare class TimeoutError extends HttpError {
+}
 /**
  * Thrown on HTTP response for a resource conflict (usually {@link http!HttpStatusCode.Conflict}).
  */
-export class ConflictError extends HttpError {}
-
+export declare class ConflictError extends HttpError {
+}
 /**
  * Thrown on HTTP response for a failed precondition or mid-air collision (usually {@link http!HttpStatusCode.PreconditionFailed}).
  */
-export class ConcurrencyError extends HttpError {}
-
+export declare class ConcurrencyError extends HttpError {
+}
 /**
  * Thrown on HTTP response for a requested range that the server can not provide (usually {@link http!HttpStatusCode.RangeNotSatisfiable}).
  */
-export class RangeNotSatisfiableError extends HttpError {}
+export declare class RangeNotSatisfiableError extends HttpError {
+}

package/http/EntityStream.d.ts

@@ -0,0 +1,10 @@
+import { Serializer } from "../serializers";
+/**
+ * Exposes the body of a `Response` as a stream of deserialized entities.
+ * @typeParam TEntity The type of entity the stream provides.
+ * @param response The response to read the body from.
+ * @param serializer Controls the deserialization of the entities in the body.
+ * @param separator The character sequence used to detect that a new entity starts in the stream.
+ * @returns A stream that ends when the server closes the connection.
+ */
+export declare function entityStream<TEntity>(response: Response, serializer: Serializer, separator?: string): AsyncIterableIterator<TEntity>;

package/http/FetchHttpClient.d.ts

@@ -0,0 +1,15 @@
+import { HttpMethod } from "./HttpMethod";
+import { HttpClient } from "./HttpClient";
+/**
+ * Communicates with remote resources using JavaScript's standard Fetch API.
+ */
+export declare class FetchHttpClient implements HttpClient {
+    /**
+     * @inheritDoc
+     */
+    defaultHeaders: Headers;
+    /**
+     * @inheritDoc
+     */
+    send(uri: URL, method: HttpMethod, signal?: AbortSignal, headers?: RequestInit["headers"], body?: RequestInit["body"]): Promise<Response>;
+}

package/http/FetchHttpClient.js

@@ -25,4 +25,4 @@ class FetchHttpClient {
     }
 }
 exports.FetchHttpClient = FetchHttpClient;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmV0Y2hIdHRwQ2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiRmV0Y2hIdHRwQ2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBOztHQUVHO0FBQ0gsTUFBYSxlQUFlO0lBQTVCO1FBQ0k7O1dBRUc7UUFDSCxtQkFBYyxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7SUFlbkMsQ0FBQztJQWJHOztPQUVHO0lBQ0gsSUFBSSxDQUFDLEdBQVEsRUFBRSxNQUFrQixFQUFFLE1BQW9CLEVBQUUsT0FBcUIsRUFBRSxJQUFlO1FBQzNGLE1BQU0sYUFBYSxHQUFHLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzNDLElBQUksQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFO1lBQ3ZDLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQzFCLGFBQWEsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ2xDLENBQUM7UUFDTCxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxhQUFhLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUM3RSxDQUFDO0NBQ0o7QUFuQkQsMENBbUJDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmV0Y2hIdHRwQ2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiRmV0Y2hIdHRwQ2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBOztHQUVHO0FBQ0gsTUFBYSxlQUFlO0lBQTVCO1FBQ0k7O1dBRUc7UUFDSCxtQkFBYyxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7SUFlbkMsQ0FBQztJQWJHOztPQUVHO0lBQ0gsSUFBSSxDQUFDLEdBQVEsRUFBRSxNQUFrQixFQUFFLE1BQW9CLEVBQUUsT0FBZ0MsRUFBRSxJQUEwQjtRQUNqSCxNQUFNLGFBQWEsR0FBRyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUMzQyxJQUFJLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRTtZQUN2QyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUMxQixhQUFhLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztZQUNsQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFDN0UsQ0FBQztDQUNKO0FBbkJELDBDQW1CQyJ9

package/http/{HttpClient.ts → HttpClient.d.ts}

@@ -1,5 +1,4 @@
 import { HttpMethod } from "./HttpMethod";
-
 /**
  * HTTP client used to communicate with remote resources.
  */
@@ -8,7 +7,6 @@ export interface HttpClient {
      * Default HTTP headers to set for requests when not explicitly overridden.
      */
     defaultHeaders: Headers;
-
     /**
      * Sends an HTTP request.
      * @param uri The URI to send the message to.
@@ -17,5 +15,5 @@ export interface HttpClient {
      * @param headers The HTTP headers to set.
      * @param body The body to send.
      */
-    send(uri: URL, method: HttpMethod, signal?: AbortSignal, headers?: HeadersInit, body?: BodyInit): Promise<Response>;
+    send(uri: URL, method: HttpMethod, signal?: AbortSignal, headers?: RequestInit["headers"], body?: RequestInit["body"]): Promise<Response>;
 }

package/http/HttpContentRange.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Describes which subset of a set of elements a response contains.
+ */
+export declare class HttpContentRange {
+    readonly unit: string;
+    readonly from?: number | undefined;
+    readonly to?: number | undefined;
+    readonly length?: number | undefined;
+    /**
+     * Creates a new content range.
+     * @param unit The unit the range is expressed in, e.g. `elements`.
+     * @param from The index at which the data starts.
+     * @param to The index at which the data stops.
+     * @param length The total number of elements available on the server; `undefined` if unknown.
+     */
+    constructor(unit: string, from?: number | undefined, to?: number | undefined, length?: number | undefined);
+    private static readonly pattern;
+    /**
+     * Extracts the content range from a `Response`.
+     * @returns The content range; `undefined` if the response has no (valid) {@link HttpHeader.ContentRange} header.
+     */
+    static from(response: Response): HttpContentRange | undefined;
+}

package/http/{HttpHeader.ts → HttpHeader.d.ts}

@@ -1,4 +1,4 @@
-export enum HttpHeader {
+export declare enum HttpHeader {
     Authorization = "Authorization",
     ContentType = "Content-Type",
     Accept = "Accept",

package/http/{HttpMethod.ts → HttpMethod.d.ts}

@@ -1,4 +1,4 @@
-export enum HttpMethod {
+export declare enum HttpMethod {
     Get = "GET",
     Post = "POST",
     Put = "PUT",

package/http/{HttpStatusCode.ts → HttpStatusCode.d.ts}

@@ -1,4 +1,4 @@
-export enum HttpStatusCode {
+export declare enum HttpStatusCode {
     OK = 200,
     Created = 201,
     Accepted = 202,

package/http/ResponseCache.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Caches the contents of a `Response`.
+ */
+export declare class ResponseCache {
+    readonly content: string;
+    readonly contentType?: string | undefined;
+    readonly eTag?: string | undefined;
+    /**
+     * Creates a new cache.
+     * @param content The content of the `Response`.
+     * @param contentType The MIME type of the `content`.
+     * @param eTag The E-Tag associated with the `content`.
+     */
+    constructor(content: string, contentType?: string | undefined, eTag?: string | undefined);
+    /**
+     * Creates a new cache from a `Response`.
+     */
+    static from(response: Response): Promise<ResponseCache>;
+}

package/http/RetryAfter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extracts the delay a server has asked clients to wait for before retrying a request.
+ * @param response The response to read the {@link HttpHeader.RetryAfter} header from.
+ * @returns The delay in milliseconds; `undefined` if the response has no (valid) header.
+ */
+export declare function retryAfter(response: Response): number | undefined;

package/http/ServerSentEvents.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A single event read from a Server-Sent Events (SSE) stream.
+ */
+export declare class ServerSentEvent {
+    readonly type: string;
+    readonly data: string;
+    readonly id?: string | undefined;
+    /**
+     * Creates a new event.
+     * @param type The event type from the `event:` field. {@link defaultEventType} if the server did not specify one.
+     * @param data The concatenated content of the event's `data:` fields.
+     * @param id The id of the most recent `id:` field if any.
+     */
+    constructor(type: string, data: string, id?: string | undefined);
+}
+/**
+ * The event type used for events without an explicit `event:` field.
+ */
+export declare const defaultEventType = "message";
+/**
+ * Reads {@link ServerSentEvent}s from the body of a `Response` in the `text/event-stream` format.
+ */
+export declare class SseReader {
+    private readonly response;
+    /**
+     * Creates a new reader.
+     * @param response The response to read the body from.
+     */
+    constructor(response: Response);
+    private _lastEventId?;
+    /**
+     * The id of the most recent event that carried an `id:` field.<br>
+     * Send this back as a {@link HttpHeader.LastEventId} header when reconnecting to let the server resume where it left off.
+     */
+    get lastEventId(): string | undefined;
+    private _reconnectionInterval?;
+    /**
+     * The reconnection interval in milliseconds most recently requested by the server via a `retry:` field if any.
+     */
+    get reconnectionInterval(): number | undefined;
+    /**
+     * Reads events until the stream ends.<br>
+     * Any event that is still incomplete when the stream ends is discarded.
+     */
+    events(): AsyncIterableIterator<ServerSentEvent>;
+    /**
+     * Splits the response body into lines, accepting `\n`, `\r\n` and `\r` as terminators.
+     */
+    private lines;
+}

package/links/AggregateLinkExtractor.d.ts

@@ -0,0 +1,17 @@
+import { Link } from "./Link";
+import { LinkExtractor } from "./LinkExtractor";
+/**
+ * Combines the results of multiple {@link LinkExtractor}s.
+ */
+export declare class AggregateLinkExtractor implements LinkExtractor {
+    private extractors;
+    /**
+     * Creates a new aggregate link extractor.
+     * @param extractors The link extractors to aggregate.
+     */
+    constructor(...extractors: LinkExtractor[]);
+    /**
+     * @inheritDoc
+     */
+    getLinks(response: Response): Promise<Link[]>;
+}

package/links/HalLinkExtractor.d.ts

@@ -0,0 +1,13 @@
+import { Link } from "./Link";
+import { LinkExtractor } from "./LinkExtractor";
+/**
+ * Extracts links from JSON bodies according to the Hypertext Application Language (HAL) specification.
+ */
+export declare class HalLinkExtractor implements LinkExtractor {
+    /**
+     * @inheritDoc
+     */
+    getLinks(response: Response): Promise<Link[]>;
+    private parseJsonBody;
+    private parseLink;
+}

package/links/HeaderLinkExtractor.d.ts

@@ -0,0 +1,13 @@
+import { Link } from "./Link";
+import { LinkExtractor } from "./LinkExtractor";
+/**
+ * Extracts links from HTTP headers.
+ */
+export declare class HeaderLinkExtractor implements LinkExtractor {
+    /**
+     * @inheritDoc
+     */
+    getLinks(response: Response): Promise<Link[]>;
+    private parseLink;
+    private split;
+}

package/links/{Link.ts → Link.d.ts}

@@ -1,7 +1,11 @@
 /**
  * Represents a link to another resource.
  */
-export class Link {
+export declare class Link {
+    rel: string;
+    href: string;
+    title?: string | undefined;
+    templated: boolean;
     /**
      * Creates a new link.
      * @param rel The relation type of the link.
@@ -9,5 +13,5 @@ export class Link {
      * @param title The title of the link.
      * @param templated Indicates whether the link is an URI Template (RFC 6570).
      */
-    constructor(public rel: string, public href: string, public title?: string, public templated: boolean = false) { }
+    constructor(rel: string, href: string, title?: string | undefined, templated?: boolean);
 }

package/links/{LinkExtractor.ts → LinkExtractor.d.ts}

@@ -1,5 +1,4 @@
 import { Link } from "./Link";
-
 /**
  * Extracts links from responses.
  */