@equinor/fusion-framework-module-http 5.2.3 → 6.0.1

package/dist/types/configurator.d.ts

@@ -1,37 +1,113 @@
 import { HttpRequestHandler } from './lib/operators';
 import type { FetchRequest, IHttpClient } from './lib/client';
 import type { IHttpRequestHandler, IHttpResponseHandler } from './lib/operators';
+/**
+ * Represents the options for constructing an `IHttpClient` instance.
+ *
+ * @template TInit - The type of the initial request object used by the `IHttpClient` instance.
+ * @property {IHttpRequestHandler<TInit>} requestHandler - The request handler to be used by the `IHttpClient` instance.
+ */
 interface HttpClientConstructorOptions<TInit extends FetchRequest> {
     requestHandler: IHttpRequestHandler<TInit>;
 }
+/**
+ * Represents a constructor for an `IHttpClient` instance.
+ *
+ * @template TClient - The type of the `IHttpClient` instance to be constructed.
+ * @param uri - The base URI for the `IHttpClient` instance.
+ * @param options - The options for constructing the `IHttpClient` instance, including the request handler.
+ * @returns A new instance of the `TClient` type.
+ */
 interface HttpClientConstructor<TClient extends IHttpClient> {
     new (uri: string, options: HttpClientConstructorOptions<HttpClientRequestInitType<TClient>>): TClient;
 }
+/**
+ * Represents the options for configuring an `IHttpClient` instance.
+ *
+ * @template TClient - The type of the `IHttpClient` instance to be configured.
+ */
 export interface HttpClientOptions<TClient extends IHttpClient = IHttpClient> {
+    /** The base URI for the `IHttpClient` instance. */
     baseUri?: string;
+    /** The default scopes to be used by the `IHttpClient` instance. */
     defaultScopes?: string[];
+    /** The constructor for the `TClient` type. */
     ctor?: HttpClientConstructor<TClient>;
+    /** A callback function that is called when a new `TClient` instance is created. */
     onCreate?: (client: TClient) => void;
+    /** The request handler to be used by the `IHttpClient` instance. */
     requestHandler?: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    /** The response handler to be used by the `IHttpClient` instance. */
     responseHandler?: IHttpResponseHandler<HttpClientRequestInitType<TClient>>;
 }
+/**
+ * Utility type that extracts the request init type from an `IHttpClient` implementation.
+ * This is useful for ensuring type safety when configuring an `IHttpClient` instance.
+ *
+ * @template T - The type of the `IHttpClient` implementation.
+ * @returns The request init type for the `IHttpClient` implementation.
+ */
 export type HttpClientRequestInitType<T extends IHttpClient> = T extends IHttpClient<infer U> ? U : never;
+/**
+ * Instance for configuring http client
+ * @template TClient base type of client that the provider will create
+ */
 export interface IHttpClientConfigurator<TClient extends IHttpClient = IHttpClient> {
     readonly clients: Record<string, HttpClientOptions<TClient>>;
     readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
     readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    /**
+     * Configure a client with arguments
+     * @param name name of the client
+     * @param args option that are used cor creating a client
+     * @example
+     * ```ts
+     * configurator.http.configureClient('foo',{
+     *   baseUri: 'https://foo.bar',
+     *   defaultScopes: ['foobar/.default']
+     * });
+     * ```
+     */
     configureClient<T extends TClient>(name: string, args: HttpClientOptions<T>): IHttpClientConfigurator<TClient>;
+    /**
+     * Configure a simple client by name to an endpoint
+     * @param name name of the client
+     * @param uri base endpoint for the client
+     */
     configureClient(name: string, uri: string): IHttpClientConfigurator<TClient>;
+    /**
+     * Creates a client with callback configuration
+     * @param name name of the client
+     * @param onCreate callback when a client is created
+     * ```ts
+     * configurator.http.configureClient('foo',(client) => {
+     *   client.requestHandler.add('logger', (request) => console.log(request));
+     * });
+     * ```
+     */
     configureClient<T extends TClient>(name: string, onCreate: (client: T) => void): HttpClientConfigurator<TClient>;
+    /**
+     * Check if there is a configuration for provided name
+     */
     hasClient(name: string): boolean;
 }
+/** @inheritdoc */
 export declare class HttpClientConfigurator<TClient extends IHttpClient> implements IHttpClientConfigurator<TClient> {
     protected _clients: Record<string, HttpClientOptions<TClient>>;
+    /** Get a clone of all configured clients */
     get clients(): Record<string, HttpClientOptions<TClient>>;
+    /** default class for creation of http clients */
     readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
+    /** default request handler for http clients, applied on creation */
     readonly defaultHttpRequestHandler: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    /**
+     * Create a instance of http configuration
+     * @param client defaultHttpRequestHandler
+     */
     constructor(client: HttpClientConstructor<TClient>);
+    /** @inheritdoc */
     hasClient(name: string): boolean;
+    /** @inheritdoc */
     configureClient<T extends TClient>(name: string, args: string | HttpClientOptions<T> | HttpClientOptions<T>['onCreate']): HttpClientConfigurator<TClient>;
 }
 export default HttpClientConfigurator;

package/dist/types/errors.d.ts

@@ -1,11 +1,29 @@
+/**
+ * Represents an error that occurs when handling an HTTP response.
+ * @template TResponse The type of the HTTP response.
+ */
 export declare class HttpResponseError<TResponse = Response> extends Error {
     readonly response: TResponse;
     static Name: string;
     constructor(message: string, response: TResponse, options?: ErrorOptions);
 }
+/**
+ * Represents an error that occurs when handling a JSON response in an HTTP request.
+ * Extends the base `HttpResponseError` class.
+ *
+ * @template TType - The type of the data associated with the error.
+ * @template TResponse - The type of the HTTP response.
+ */
 export declare class HttpJsonResponseError<TType = unknown, TResponse = Response> extends HttpResponseError<TResponse> {
     static Name: string;
     readonly data?: TType;
+    /**
+     * Creates a new instance of `HttpJsonResponseError`.
+     *
+     * @param message - The error message.
+     * @param response - The HTTP response associated with the error.
+     * @param options - Additional options for the error, including the associated data.
+     */
     constructor(message: string, response: TResponse, options?: ErrorOptions & {
         data?: TType;
     });

package/dist/types/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * [[include:module-http/README.MD]]
+ * @module
+ */
 export * from './configurator';
 export * from './provider';
 export * from './module';

package/dist/types/lib/client/client-msal.d.ts

@@ -1,12 +1,55 @@
 import type { Observable } from 'rxjs';
 import type { FetchRequestInit, FetchRequest, FetchResponse } from '.';
 import { HttpClient } from './client';
+/**
+ * Extends the `FetchRequest` type with an optional `scopes` property, which is an array of strings representing the scopes to be used for the request.
+ * This type is used to represent a request that requires authentication using the MSAL (Microsoft Authentication Library) library.
+ */
 type MsalFetchRequest = FetchRequest & {
     scopes?: string[];
 };
+/**
+ * Extends the `FetchRequestInit` type with an optional `scopes` property, which is an array of strings representing the scopes to be used for the request.
+ * This type is used to represent a request that requires authentication using the MSAL (Microsoft Authentication Library) library.
+ *
+ * @template TReturn - The type of the response object. Defaults to `unknown`.
+ * @template TRequest - The type of the request object. Defaults to `FetchRequest`.
+ * @template TResponse - The type of the response object. Defaults to `Response`.
+ */
 type MsalFetchRequestInit<TReturn = unknown, TRequest = FetchRequest, TResponse = FetchResponse> = FetchRequestInit<TReturn, TRequest, TResponse> & Pick<MsalFetchRequest, 'scopes'>;
+/**
+ * Extends the `HttpClient` class to provide MSAL (Microsoft Authentication Library) authentication support.
+ *
+ * The `HttpClientMsal` class is responsible for handling requests that require authentication using the MSAL library.
+ * It extends the `HttpClient` class and adds the following functionality:
+ *
+ * - `defaultScopes`: An array of strings representing the default scopes to be used for all requests, unless overridden in the request object.
+ * - `fetch$`: Overrides the `fetch$` method of the `HttpClient` class to add MSAL authentication support. It takes an optional `MsalFetchRequestInit` object, which can include the `scopes` property to specify the scopes to be used for the request.
+ *   - If `scopes` is provided in the `MsalFetchRequestInit` object, it will be used in addition to the `defaultScopes`.
+ *   - If `scopes` is not provided, only the `defaultScopes` will be used.
+ *
+ * @template TRequest - The type of the request object. Defaults to `MsalFetchRequest`.
+ * @template TResponse - The type of the response object. Defaults to `FetchResponse`.
+ */
 export declare class HttpClientMsal<TRequest extends MsalFetchRequest = MsalFetchRequest, TResponse extends FetchResponse = FetchResponse> extends HttpClient<TRequest, TResponse> {
+    /**
+     * An array of default scopes to be used for all requests, unless overridden in the request object.
+     * This property is used by the `HttpClientMsal` class to add MSAL authentication support to requests.
+     */
     defaultScopes: string[];
+    /**
+     * Fetches a resource from the specified path, with optional MSAL authentication scopes.
+     *
+     * This method extends the `HttpClient.fetch$` method to add support for MSAL authentication.
+     * If `init.scopes` is provided, it will be used in addition to the `defaultScopes` defined in the `HttpClientMsal` class.
+     * If `init.scopes` is not provided, only the `defaultScopes` will be used for the request.
+     *
+     * @overrides HttpClient.fetch$
+     *
+     * @param path - The path to the resource to fetch.
+     * @param init - An optional `MsalFetchRequestInit` object that can include the `scopes` property.
+     * @returns An `Observable` that emits the fetched resource.
+     */
     fetch$<T = TResponse>(path: string, init?: MsalFetchRequestInit<T, TRequest, TResponse>): Observable<T>;
 }
 export default HttpClientMsal;

package/dist/types/lib/client/client.d.ts

@@ -1,34 +1,178 @@
 import { Subject } from 'rxjs';
 import type { Observable, ObservableInput } from 'rxjs';
 import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators';
-import type { FetchRequest, FetchRequestInit, FetchResponse, IHttpClient, JsonRequest, StreamResponse } from '.';
+import type { BlobResult, FetchRequest, FetchRequestInit, FetchResponse, IHttpClient, JsonRequest, StreamResponse } from './types';
+/**
+ * Configuration options for creating an `HttpClient` instance.
+ *
+ * @template TRequest - The type of the request object. Defaults to `FetchRequest`.
+ * @template TResponse - The type of the response object. Defaults to `Response`.
+ * @property {IHttpRequestHandler<TRequest>} requestHandler - A handler for customizing the request before it is sent.
+ * @property {IHttpResponseHandler<TResponse>} responseHandler - A handler for customizing the response after it is received.
+ */
 export type HttpClientCreateOptions<TRequest extends FetchRequest = FetchRequest, TResponse = Response> = {
     requestHandler: IHttpRequestHandler<TRequest>;
     responseHandler: IHttpResponseHandler<TResponse>;
 };
+/** Base http client for executing requests */
 export declare class HttpClient<TRequest extends FetchRequest = FetchRequest, TResponse extends FetchResponse = FetchResponse> implements IHttpClient<TRequest, TResponse> {
     uri: string;
+    /**
+     * A request handler that can be used to customize the request before it is sent.
+     * This property is part of the `HttpClientCreateOptions` configuration object used to create an `HttpClient` instance.
+     */
     readonly requestHandler: IHttpRequestHandler<TRequest>;
+    /**
+     * A handler for customizing the response after it is received.
+     * This property is part of the `HttpClientCreateOptions` configuration object used to create an `HttpClient` instance.
+     */
     readonly responseHandler: IHttpResponseHandler<TResponse>;
+    /**
+     * A stream of requests that are about to be executed.
+     * This property is used internally by the `HttpClient` class to manage the lifecycle of requests.
+     */
     protected _request$: Subject<TRequest>;
+    /**
+     * A stream of responses that have been received.
+     * This property is used internally by the `HttpClient` class to manage the lifecycle of responses.
+     */
     protected _response$: Subject<TResponse>;
+    /**
+     * A stream that is used to signal the abortion of requests.
+     * This property is used internally by the `HttpClient` class to manage the lifecycle of requests.
+     */
     protected _abort$: Subject<void>;
+    /**
+     * A stream of requests that are about to be executed.
+     */
     get request$(): Observable<TRequest>;
+    /**
+     * A stream of responses that have been received.
+     */
     get response$(): Observable<TResponse>;
     constructor(uri: string, options?: Partial<HttpClientCreateOptions<TRequest, TResponse>>);
+    /**
+     * Internal method called by child classes to perform initialization logic in the constructor.
+     * This method is intended to be overridden by child classes to add their own initialization logic.
+     * @protected
+     * @virtual
+     */
     protected _init(): void;
+    /**
+     * Fetches data from the specified path and returns a stream response.
+     *
+     * @param path - The path to fetch data from.
+     * @param args - Optional request initialization options, including a custom selector function.
+     * @returns A stream response containing the fetched data.
+     */
     fetch$<T = TResponse>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): StreamResponse<T>;
+    /**
+     * Fetches data from the specified path and returns a Promise containing the fetched data.
+     *
+     * @param path - The path to fetch data from.
+     * @param args - Optional request initialization options, including a custom selector function.
+     * @returns A Promise containing the fetched data.
+     */
     fetch<T = TResponse>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+    /** @deprecated */
     fetchAsync<T = TResponse>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+    /**
+     * Fetches data from the specified path and returns a stream response containing the data in JSON format.
+     *
+     * @param path - The path to fetch the data from.
+     * @param args - Optional request initialization options, including a custom selector function and request body.
+     *   - `body`: The request body, which will be automatically serialized to JSON if it's an object.
+     *   - `selector`: A custom selector function to transform the response data. If not provided, the `jsonSelector` function will be used.
+     *   - `headers`: Additional headers to include in the request. The `Accept` and `Content-Type` headers will be automatically set to `application/json`.
+     * @returns A stream response containing the fetched data in JSON format.
+     */
     json$<T = unknown>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): StreamResponse<T>;
+    /**
+     * Fetches data from the specified path and returns a Promise containing the fetched data in JSON format.
+     *
+     * @param path - The path to fetch the data from.
+     * @param args - Optional request initialization options, including a custom selector function and request body.
+     *   - `body`: The request body, which will be automatically serialized to JSON if it's an object.
+     *   - `selector`: A custom selector function to transform the response data. If not provided, the `jsonSelector` function will be used.
+     *   - `headers`: Additional headers to include in the request. The `Accept` and `Content-Type` headers will be automatically set to `application/json`.
+     * @returns A Promise containing the fetched data in JSON format.
+     */
     json<T = unknown>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): Promise<T>;
-    blob$(path: string, args?: FetchRequestInit<Blob, TRequest, TResponse>): StreamResponse<Blob>;
-    blob(path: string, args?: FetchRequestInit<Blob, TRequest, TResponse>): Promise<Blob>;
+    /**
+     * Fetches a blob resource from the specified path and returns a stream response.
+     *
+     * @param path - The path to the blob resource.
+     * @param args - Optional request initialization options, including a custom selector function.
+     * @returns A stream response containing the fetched blob data.
+     */
+    blob$<T = BlobResult>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): StreamResponse<T>;
+    /**
+     * Fetches a blob from the specified path and returns a Promise that resolves to the blob result.
+     *
+     * @param path - The path to fetch the blob from.
+     * @param args - Optional arguments for the fetch request, including request body, headers, and response type.
+     * @returns A Promise that resolves to the blob result.
+     */
+    blob<T = BlobResult>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+    /** @deprecated */
     jsonAsync<T = unknown>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): Promise<T>;
+    /**
+     * Executes an HTTP request using the specified method and path.
+     *
+     * @param method - The HTTP method to use for the request, such as 'fetch', 'json', or 'blob'.
+     * @param path - The path to the resource to fetch.
+     * @param init - Optional request initialization options, including request body, headers, and response type.
+     * @returns The result of the HTTP request, which will be of the same type as the return value of the specified method.
+     */
     execute<T = TResponse, TMethod extends 'fetch' | 'fetch$' | 'json' | 'json$' = 'fetch'>(method: TMethod, path: string, init?: FetchRequestInit<T, TRequest, TResponse>): ReturnType<IHttpClient[TMethod]>;
+    /**
+     * Aborts any ongoing HTTP requests made by this `IHttpClient` instance.
+     * This will trigger the `takeUntil` operator in the `_fetch$` method,
+     * causing any in-flight requests to be cancelled.
+     */
     abort(): void;
+    /**
+     * Fetches data from the specified path and returns an Observable that emits the response.
+     *
+     * @param path - The path to fetch the data from.
+     * @param args - Optional arguments for the fetch request, including a response selector function, request body, headers, and response type.
+     * @returns {Observable<T>} An Observable that emits the response data.
+     *
+     * This method handles the following steps:
+     * 1. Resolves the full URL by combining the base URI and the provided path.
+     * 2. Prepares the request by passing it through the `requestHandler.process()` method.
+     * 3. Executes the fetch request using the prepared request.
+     * 4. Prepares the response by passing it through the `responseHandler.process()` method.
+     * 5. Applies the optional response selector function to transform the response data.
+     * 6. Cancels the request if the `_abort$` observable emits.
+     */
     protected _fetch$<T = TResponse>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): Observable<T>;
+    /**
+     * Prepares the request by passing it through the `requestHandler.process()` method.
+     * This method is an implementation detail of the `_fetch$()` method, and is not part of the public API.
+     * It takes a `TRequest` object as input, which represents the request data, and returns an `ObservableInput<TRequest>`,
+     * which can be used to further process the request before it is executed.
+     *
+     * @param init The request data to be processed.
+     * @returns An `ObservableInput<TRequest>` that represents the processed request.
+     */
     protected _prepareRequest(init: TRequest): ObservableInput<TRequest>;
+    /**
+     * Prepares the response by passing it through the `responseHandler.process()` method.
+     * This method is an implementation detail of the `_fetch$()` method, and is not part of the public API.
+     * It takes a `TResponse` object as input, which represents the response data, and returns an `ObservableInput<TResponse>`,
+     * which can be used to further process the response before it is returned.
+     *
+     * @param response The response data to be processed.
+     * @returns An `ObservableInput<TResponse>` that represents the processed response.
+     */
     protected _prepareResponse(response: TResponse): ObservableInput<TResponse>;
+    /**
+     * Resolves the full URL for a given path by combining it with the base URL.
+     * This is a protected method and is an implementation detail of the `HttpClient` class.
+     *
+     * @param path - The path to be resolved.
+     * @returns The full URL for the given path.
+     */
     protected _resolveUrl(path: string): string;
 }

package/dist/types/lib/client/types.d.ts

@@ -1,36 +1,187 @@
 import type { ObservableInput, Observable } from 'rxjs';
 import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators/types';
+/**
+ * Represents a stream of response data.
+ * @template T - The type of the response data.
+ */
 export type StreamResponse<T> = Observable<T>;
+/**
+ * A function that takes a `Response` object and returns an `ObservableInput` of type `T`.
+ *
+ * @template TResult - The type of the data contained in the response.
+ * @template TResponse - The type of the response object.
+ * @param response - The `Response` object to be processed.
+ * @returns An `ObservableInput` of type `T`.
+ */
+export type ResponseSelector<TResult = unknown, TResponse = Response> = (response: TResponse) => ObservableInput<TResult>;
+/**
+ * Represents the parameters for a fetch request, including the URI and path.
+ * @property {string} uri - The URI of the request.
+ * @property {string} path - The path of the request.
+ */
 export type FetchRequest = RequestInit & {
     uri: string;
     path: string;
 };
+/**
+ * Represents a request with a JSON body.
+ * @template TRequest - The base request type, which extends `FetchRequest`.
+ * @property {object | string | null} [body] - The request body, which can be an object, a string, or null.
+ */
 export type JsonRequest<TRequest extends FetchRequest = FetchRequest> = Omit<TRequest, 'body'> & {
     body?: object | string | null;
 };
+/**
+ * Represents the result of a blob operation, including the filename (if available) and the blob itself.
+ * @property {string} [filename] - The filename of the blob, if available.
+ * @property {Blob} blob - The blob data.
+ */
+export type BlobResult = {
+    filename?: string;
+    blob: Blob;
+};
+/**
+ * Represents the response from a fetch request, including the response object and a JSON parsing method.
+ * @template T - The type of the response data.
+ * @property {Response} - The original Response object.
+ * @property {() => Promise<T>} json - A method to parse the response body as JSON and return the data as type T.
+ */
 export type FetchResponse<T = unknown> = Response & {
     json(): Promise<T>;
 };
+/**
+ * Represents the parameters for a fetch request, including the URI and path, as well as a selector function to transform the response.
+ * @template TReturn - The type of the transformed response data.
+ * @template TRequest - The type of the fetch request.
+ * @template TResponse - The type of the fetch response.
+ */
 export type FetchRequestInit<TReturn = unknown, TRequest = FetchRequest, TResponse = FetchResponse<TReturn>> = Omit<TRequest, 'uri' | 'path'> & {
-    selector?: (response: TResponse) => ObservableInput<TReturn>;
+    /** response selector function */
+    selector?: ResponseSelector<TReturn, TResponse>;
 };
+/**
+ * Represents the parameters for a fetch request, including the URI and path, as well as a selector function to transform the response.
+ *
+ * @template TReturn - The type of the transformed response data.
+ * @template TRequest - The type of the fetch request.
+ * @template TResponse - The type of the fetch response.
+ */
 export type ClientRequestInit<T extends IHttpClient, TReturn = unknown> = T extends IHttpClient<infer TRequest, infer TResponse> ? FetchRequestInit<TReturn, TRequest, TResponse> : never;
+/**
+ * Represents the available execution methods for an HTTP client.
+ */
 export type ExecutionMethod = 'fetch' | 'fetch$' | 'json' | 'json$';
+/**
+ * Represents the type of the parameters for the execution methods of an `IHttpClient` instance.
+ *
+ * @template TMethod - The execution method of the `IHttpClient` instance, e.g. 'fetch', 'json'.
+ * @template TClient - The type of the `IHttpClient` instance.
+ */
 export type ExecutionMethodParameters<TMethod extends ExecutionMethod = 'fetch', TClient extends IHttpClient = IHttpClient> = Parameters<TClient[TMethod]>;
+/**
+ * Represents the type of the return value for the execution methods of an `IHttpClient` instance.
+ *
+ * @template TMethod - The execution method of the `IHttpClient` instance, e.g. 'fetch', 'json'.
+ * @template TClient - The type of the `IHttpClient` instance.
+ */
 export type ExecutionResponse<TMethod extends ExecutionMethod = 'fetch', TClient extends IHttpClient = IHttpClient> = ReturnType<TClient[TMethod]>;
+/**
+ * @template TRequest request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/request|request}
+ * @template TResponse request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/response|response}
+ */
 export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response> {
     uri: string;
+    /**
+     * A pre-processor for requests made by the `IHttpClient` interface.
+     * This handler can be used to modify the request before it is sent, such as adding headers, authentication, or other transformations.
+     */
     readonly requestHandler: IHttpRequestHandler<TRequest>;
+    /**
+     * A post-processor for responses received by the `IHttpClient` interface.
+     * This handler can be used to transform the response data after it is received, such as parsing JSON, handling errors, or other transformations.
+     */
     readonly responseHandler: IHttpResponseHandler<TResponse>;
-    request$: Observable<TRequest>;
-    response$: Observable<TResponse>;
+    /**
+     * Observable stream of requests made by the `IHttpClient` interface.
+     * This stream can be used to observe and potentially modify the requests before they are sent.
+     */
+    readonly request$: Observable<TRequest>;
+    /**
+     * Observable stream of responses received by the `IHttpClient` interface.
+     * This stream can be used to observe and potentially handle the responses after they are received.
+     */
+    readonly response$: Observable<TResponse>;
+    /**
+     * Fetch a resource as an observable stream.
+     * This method simplifies the execution of a request and returns an observable stream of the response.
+     * The request will not be executed until the observable is subscribed to.
+     *
+     * @template T - The expected response type.
+     * @param path - The path to fetch the resource from.
+     * @param init - Optional request initialization options.
+     * @returns An observable stream of the response.
+     *
+     * @see {@link https://rxjs.dev/api/fetch/fromFetch|RxJS fromFetch}
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch|fetch}
+     */
     fetch$<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): StreamResponse<T>;
+    /**
+     * Fetch a resource as a promise.
+     *
+     * @template T - The expected response type.
+     * @param path - The path to fetch the resource from.
+     * @param init - Optional request initialization options.
+     * @returns A promise that resolves to the fetched resource.
+     *
+     * @see {@link IHttpClient.fetch$}
+     */
     fetch<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+    /** @deprecated use {@link IHttpClient.fetch} */
     fetchAsync<T = TResponse>(path: string, args?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+    /**
+     * Fetches a resource as an observable stream.
+     * This method simplifies the execution of a request and returns an observable stream of the response.
+     * The request will not be executed until the observable is subscribed to.
+     *
+     * @template T - The expected response type.
+     * @param path - The path to fetch the resource from.
+     * @param init - Optional request initialization options, including the request body, headers, and response type.
+     * @returns An observable stream of the fetched resource.
+     *
+     * @see {@link IHttpClient.fetch$}
+     */
     json$<T = unknown>(path: string, init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): StreamResponse<T>;
+    /**
+     * Fetches a resource as a promise and returns the response as a JSON object.
+     *
+     * @template T - The expected response type.
+     * @param path - The path to fetch the resource from.
+     * @param init - Optional request initialization options, including the request body, headers, and response type.
+     * @returns A promise that resolves to the fetched resource as a JSON object.
+     *
+     * @see {@link IHttpClient.fetch} for fetching resources as an observable stream.
+     */
     json<T = unknown>(path: string, init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): Promise<T>;
+    /** @deprecated */
     jsonAsync<T = unknown>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): Promise<T>;
-    blob(path: string, args?: FetchRequestInit<Blob, JsonRequest<TRequest>, TResponse>): Promise<Blob>;
-    blob$(path: string, args?: FetchRequestInit<Blob, JsonRequest<TRequest>, TResponse>): StreamResponse<Blob>;
+    /**
+     * Fetches a blob resource from the specified path and returns a Promise that resolves to the fetched blob data.
+     *
+     * @param path - The path to fetch the blob from.
+     * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
+     * @returns A Promise that resolves to the fetched blob data.
+     */
+    blob<T = BlobResult>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): Promise<T>;
+    /**
+     * Fetches a blob from the specified path and returns a stream response.
+     *
+     * @param path - The path to fetch the blob from.
+     * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
+     * @returns A stream response containing the fetched blob.
+     */
+    blob$<T = BlobResult>(path: string, args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>): StreamResponse<T>;
+    /**
+     * Abort all ongoing requests for the current client.
+     */
     abort(): void;
 }

package/dist/types/lib/operators/http-request-handler.d.ts

@@ -1,6 +1,22 @@
 import { ProcessOperators } from './process-operators';
 import type { FetchRequest } from '../client';
+/**
+ * Extends the `ProcessOperators` class to handle HTTP requests.
+ *
+ * This class provides a method to set a header that will apply to all requests made by the `HttpClient`.
+ *
+ * @see {@link ProcessOperators}
+ *
+ * @template T - The type of the fetch request, which extends `FetchRequest`.
+ */
 export declare class HttpRequestHandler<T extends FetchRequest = FetchRequest> extends ProcessOperators<T> {
+    /**
+     * Sets a header that will apply to all requests made by the `HttpClient`.
+     *
+     * @param key - The name of the header to set.
+     * @param value - The value of the header to set.
+     * @returns The current `HttpRequestHandler` instance, allowing for method chaining.
+     */
     setHeader(key: string, value: string): HttpRequestHandler<T>;
 }
 export default HttpRequestHandler;

package/dist/types/lib/operators/http-response-handler.d.ts

@@ -1,4 +1,10 @@
 import { ProcessOperators } from './process-operators';
+/**
+ * The `HttpResponseHandler` class extends the `ProcessOperators` class and is responsible for handling HTTP responses.
+ * It provides a common interface for processing HTTP responses, allowing for consistent error handling and response transformation.
+ *
+ * @template T - The type of the HTTP response. Defaults to `Response`.
+ */
 export declare class HttpResponseHandler<T = Response> extends ProcessOperators<T> {
 }
 export default HttpResponseHandler;