@optionfactory/fml 8.0.3 → 9.0.0-rc1

package/dist/httpc.iife.js

@@ -4,6 +4,11 @@ var httpc = (function (exports) {
     /**
      * @typedef {{ type: string; context: string?; reason: string; details: any?; }} Problem
      */
+    /**
+     * An error carrying a list of problems rather than one message. A problem's
+     * `context` names the field it belongs to, which is what lets a form show each
+     * one beside its own input instead of in a banner.
+     */
     class Failure extends Error {
         /**
          *
@@ -16,18 +21,55 @@ var httpc = (function (exports) {
             this.name = 'Failure';
             this.problems = problems;
         }
+        /**
+         * Returns a copy whose problems' contexts have the prefix removed, so a
+         * caller can rethrow namespaced problems as its own.
+         * @param {string} prefix
+         * @returns {Failure}
+         */
         dropping(prefix) {
             return new Failure(this.message, Failure.dropProblemsContext(this.problems, prefix), this);
         }
+        /**
+         * @param {Problem[]} problems
+         * @param {string} prefix
+         * @returns {Problem[]}
+         */
         static dropProblemsContext(problems, prefix) {
             return problems.map(({ type, context, reason, details }) => {
                 const nctx = context?.startsWith(prefix) ? context.substring(prefix.length) : context;
                 return { type, context: nctx, reason, details };
             });
         }
+        /**
+         * The one reading of a failure: its problems' reasons, one per line, or
+         * the fallback when the value carries none. An empty problems array
+         * carries nothing: the failure's own message reads instead.
+         *
+         * @param {any} cause
+         * @param {string|null} [fallback]
+         * @returns {string}
+         */
+        static problemsText(cause, fallback = null) {
+            if (cause?.problems?.length) {
+                return cause.problems.map((p) => `${p.reason}`).join('\n');
+            }
+            return fallback ?? `${cause?.message ?? cause}`;
+        }
     }
 
+    /**
+     * Base64 encoding and decoding over ArrayBuffers, in the STANDARD and URL_SAFE
+     * alphabets. The encoder never emits padding; the decoder accepts both padded
+     * and unpadded input, and rejects anything it cannot decode faithfully instead
+     * of corrupting silently.
+     */
     class Base64 {
+        /**
+         * @param {ArrayBuffer} arrayBuffer
+         * @param {string} [dialect] one of Base64.STANDARD or Base64.URL_SAFE, URL_SAFE by default
+         * @returns {string} the unpadded encoding
+         */
         static encode(arrayBuffer, dialect) {
             const d = dialect || Base64.URL_SAFE;
             const len = arrayBuffer.byteLength;
@@ -47,15 +89,32 @@ var httpc = (function (exports) {
             }
             return res;
         }
+        /**
+         * @param {string} str
+         * @param {string} [dialect] one of Base64.STANDARD or Base64.URL_SAFE, URL_SAFE by default
+         * @returns {ArrayBuffer}
+         */
         static decode(str, dialect) {
             const d = dialect || Base64.URL_SAFE;
-            let nbytes = Math.floor(str.length * 0.75);
-            for (let i = 0; i !== str.length; ++i) {
-                if (str[str.length - i - 1] !== '=') {
-                    break;
+            //padding belongs at the tail only, two at most, and nothing outside the
+            //dialect decodes: reject instead of corrupting silently
+            let end = str.length;
+            while (end > 0 && str.charAt(end - 1) === '=') {
+                --end;
+            }
+            const unpadded = str.substring(0, end);
+            if (str.length - end > 2 || unpadded.includes('=') || (unpadded.length === 0 && str.length > 0)) {
+                throw new Error('invalid padding');
+            }
+            if (unpadded.length % 4 === 1) {
+                throw new Error('invalid length');
+            }
+            for (const c of unpadded) {
+                if (d.indexOf(c) === -1) {
+                    throw new Error(`invalid character '${c}'`);
                 }
-                --nbytes;
             }
+            const nbytes = Math.floor(unpadded.length * 0.75);
             const view = new Uint8Array(nbytes);
 
             let vi = 0;
@@ -64,10 +123,10 @@ var httpc = (function (exports) {
             //one or two: writing them anyway would rely on typed arrays dropping writes
             //past their length
             while (vi < nbytes) {
-                const v1 = d.indexOf(str.charAt(si++));
-                const v2 = d.indexOf(str.charAt(si++));
-                const v3 = d.indexOf(str.charAt(si++));
-                const v4 = d.indexOf(str.charAt(si++));
+                const v1 = d.indexOf(unpadded.charAt(si++));
+                const v2 = d.indexOf(unpadded.charAt(si++));
+                const v3 = d.indexOf(unpadded.charAt(si++));
+                const v4 = d.indexOf(unpadded.charAt(si++));
                 view[vi++] = (v1 << 2) | (v2 >> 4);
                 if (vi === nbytes) {
                     break;
@@ -86,11 +145,21 @@ var httpc = (function (exports) {
     Base64.STANDARD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
     Base64.URL_SAFE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 
+    /**
+     * Hex encoding and decoding over byte sequences, lowercase by default.
+     */
     class Hex {
+        /**
+         * @param {string} hex
+         * @returns {Uint8Array}
+         */
         static decode(hex) {
             if (hex.length % 2 !== 0) {
                 throw new Error('invalid length');
             }
+            if (!/^[0-9a-fA-F]*$/.test(hex)) {
+                throw new Error('invalid character');
+            }
             const lenInBytes = hex.length / 2;
             return new Uint8Array(lenInBytes).map((e, i) => {
                 const offset = i * 2;
@@ -98,6 +167,11 @@ var httpc = (function (exports) {
                 return parseInt(octet, 16);
             });
         }
+        /**
+         * @param {Iterable<number>} bytes
+         * @param {boolean} [upper]
+         * @returns {string}
+         */
         static encode(bytes, upper) {
             return Array.from(bytes)
                 .map((b) => b.toString(16))
@@ -107,6 +181,7 @@ var httpc = (function (exports) {
         }
     }
 
+    /** A parsed `Content-Type`: the type and subtype without the parameters, so a comparison is not defeated by a charset. */
     class MediaType {
         #type;
         #subtype;
@@ -124,7 +199,7 @@ var httpc = (function (exports) {
             return this.#subtype;
         }
         /**
-         *
+         * Parses a Content-Type header value into its type/subtype pair, dropping any parameter.
          * @param {string|null|undefined} v
          * @returns
          */
@@ -133,8 +208,11 @@ var httpc = (function (exports) {
                 return new MediaType('unknown', 'unknown');
             }
             const [prefix, _] = v.split(';');
-            const [ptype, psubtype] = prefix.trim().split('/');
-            return new MediaType(ptype.toLowerCase(), psubtype?.toLowerCase());
+            const [ptype, psubtype] = prefix.trim().toLowerCase().split('/');
+            if (!ptype || !psubtype) {
+                return new MediaType('unknown', 'unknown');
+            }
+            return new MediaType(ptype, psubtype);
         }
     }
 
@@ -146,6 +224,11 @@ var httpc = (function (exports) {
      * @property {(url: URL, init: RequestInit|undefined, chain: HttpInterceptorChain) => Promise<Response>} intercept
      */
 
+    /**
+     * A Failure from an http exchange, carrying the status that was served. Status
+     * 0 means no response was served at all: the transport failed, or a body the
+     * server did send could not be read.
+     */
     class HttpClientError extends Failure {
         /**
          * @param {string} message
@@ -158,29 +241,33 @@ var httpc = (function (exports) {
             this.name = 'HttpClientError';
             this.status = status;
         }
+        /**
+         * Returns a copy whose problems' contexts have the prefix removed, keeping
+         * this error's status.
+         * @param {string} prefix
+         * @returns {HttpClientError}
+         */
         dropping(prefix) {
             return new HttpClientError(this.message, this.status, Failure.dropProblemsContext(this.problems, prefix), this);
         }
         /**
-         *
+         * One problem of the client's own making: the four the client mints are the
+         * same shape, and the server's arrive already shaped from the wire.
+         * @param {string} type
+         * @param {string} reason
+         */
+        static problem(type, reason) {
+            return { type, context: null, reason, details: null };
+        }
+        /**
+         * Creates a client failure carrying no status, wrapping the cause and its message.
          * @param {string} type
          * @param {any} cause
          * @returns
          */
         static of(type, cause) {
-            return new HttpClientError(
-                cause.message,
-                0,
-                [
-                    {
-                        type,
-                        context: null,
-                        reason: cause.message,
-                        details: null,
-                    },
-                ],
-                cause,
-            );
+            const reason = String(cause?.message ?? cause ?? 'unknown failure');
+            return new HttpClientError(reason, 0, [HttpClientError.problem(type, reason)], cause);
         }
         /**
          * Creates an HttpClientError from a Response.
@@ -190,55 +277,86 @@ var httpc = (function (exports) {
         static async fromResponse(response) {
             switch (MediaType.parse(response.headers.get('Content-Type')).normalized) {
                 case 'application/failures+json': {
-                    const data = await response.json();
+                    const data = await response.json().catch(() => HttpClientError.#unreadable);
+                    if (data === HttpClientError.#unreadable) {
+                        return HttpClientError.#undecodable(response);
+                    }
+                    if (!Array.isArray(data)) {
+                        return HttpClientError.#undecodable(response, 'as a failures array');
+                    }
                     const message = `${response.status} ${response.statusText}: ${data.length} failures`;
                     return new HttpClientError(message, response.status, data);
                 }
                 case 'application/problem+json': {
-                    const data = await response.json();
+                    const data = await response.json().catch(() => HttpClientError.#unreadable);
+                    if (data === HttpClientError.#unreadable) {
+                        return HttpClientError.#undecodable(response);
+                    }
+                    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+                        return HttpClientError.#undecodable(response, 'as a problem object');
+                    }
                     const message = `${response.status} ${response.statusText}: ${data.title} ${data.detail}`;
                     return new HttpClientError(
                         message,
                         response.status,
-                        data.problems || [
-                            {
-                                type: 'GENERIC_PROBLEM',
-                                context: null,
-                                reason: message,
-                                details: null,
-                            },
-                        ],
+                        data.problems || [HttpClientError.problem('GENERIC_PROBLEM', message)],
                     );
                 }
                 default: {
-                    const text = await response.text();
-                    const message = `${response.status} ${response.statusText}: ${text}`;
-                    return new HttpClientError(message, response.status, [
-                        {
-                            type: 'GENERIC_PROBLEM',
-                            context: null,
-                            reason: message,
-                            details: null,
-                        },
-                    ]);
+                    return HttpClientError.#generic(response);
                 }
             }
         }
+        /** marks a body whose json() rejected, telling it apart from a body decoding to json null */
+        static #unreadable = Symbol('unreadable body');
+        /**
+         * A json body that failed to decode, or that decoded to something other than
+         * the declared contract, has consumed its stream: there is no text left to
+         * embed, the status, the declared media type and the shape are the report.
+         * @param {Response} response
+         * @param {string} [as] - what the body does not decode as
+         */
+        static #undecodable(response, as = 'as json') {
+            const mediaType = MediaType.parse(response.headers.get('Content-Type')).normalized;
+            const message = `${response.status} ${response.statusText}: the ${mediaType} body does not decode ${as}`;
+            return new HttpClientError(message, response.status, [HttpClientError.problem('GENERIC_PROBLEM', message)]);
+        }
+        static async #generic(response) {
+            //a body that cannot be read (the connection cut mid-body) must not
+            //masquerade as a connection problem: the response was served, its
+            //status is the report
+            const text = await response.text().catch(() => null);
+            const message =
+                text === null
+                    ? `${response.status} ${response.statusText}: the body could not be read`
+                    : `${response.status} ${response.statusText}: ${text}`;
+            return new HttpClientError(message, response.status, [HttpClientError.problem('GENERIC_PROBLEM', message)]);
+        }
     }
 
+    const metaContent = (name) =>
+        globalThis.document?.querySelector(`meta[name="${name}"]`)?.getAttribute('content') ?? undefined;
+
     /**
      * @implements {HttpInterceptor}
      */
+    /**
+     * Sends the csrf header named by the page's `_csrf_header` meta, with the token
+     * from `_csrf`. Both are read per request, so metas replaced after the client
+     * was built are honoured, and the header is sent to the page's own origin only.
+     */
     class CsrfTokenInterceptor {
-        #k;
-        #v;
-        constructor() {
-            this.#k = document.querySelector("meta[name='_csrf_header']")?.getAttribute('content');
-            this.#v = document.querySelector("meta[name='_csrf']")?.getAttribute('content');
-        }
         async intercept(url, request, chain) {
-            if (this.#k && this.#v) {
-                request.headers.set(this.#k, this.#v);
+            //the token is the page's own: it travels to the page's origin only, and it
+            //is read at request time, so metas landed after the client was built (a
+            //login flow) are honored without a rebuild
+            if (url.origin !== (globalThis.window?.location?.origin ?? url.origin)) {
+                return await chain.proceed(url, request);
+            }
+            const csrfHeader = metaContent('_csrf_header');
+            const csrfToken = metaContent('_csrf');
+            if (csrfHeader && csrfToken) {
+                request.headers.set(csrfHeader, csrfToken);
             }
             return await chain.proceed(url, request);
         }
@@ -246,6 +364,11 @@ var httpc = (function (exports) {
     /**
      * @implements {HttpInterceptor}
      */
+    /**
+     * Navigates to a login url when a response comes back 401. The promise it
+     * returns never settles, so callers keep waiting while the page unloads
+     * instead of showing a failure nobody will be present to read.
+     */
     class RedirectOnUnauthorizedInterceptor {
         #redirectUri;
         /**
@@ -258,12 +381,17 @@ var httpc = (function (exports) {
             const response = await chain.proceed(url, request);
             if (response.status === 401) {
                 window.location.href = this.#redirectUri;
+                //the page is navigating away: a promise that never settles keeps the
+                //callers' spinners up instead of flashing a failure nobody will read.
+                //Where the navigation is blocked (a beforeunload gate), they stay
+                //pending until the page actually leaves
                 return new Promise(() => {});
             }
             return response;
         }
     }
 
+    /** Collects the interceptors an HttpClient will run, in the order they are added. */
     class HttpClientBuilder {
         /**
          * @type {HttpInterceptor[]}
@@ -295,12 +423,21 @@ var httpc = (function (exports) {
     /**
      * @implements {HttpInterceptor}
      */
+    /** The last interceptor in every chain: the one that performs the request. */
     class HttpCall {
         async intercept(url, request, chain) {
-            return await fetch(url, request);
+            try {
+                return await fetch(url, request);
+            } catch (ex) {
+                //the one place a connection problem is a connection problem: the
+                //transport itself refused to deliver. Everything above this is code,
+                //and code that throws has a different story to tell
+                throw HttpClientError.of('CONNECTION_PROBLEM', ex);
+            }
         }
     }
 
+    /** One request's position in the interceptor list: `proceed` runs the next interceptor, the last of which performs the request. */
     class HttpInterceptorChain {
         #interceptors;
         #current;
@@ -329,6 +466,11 @@ var httpc = (function (exports) {
         }
     }
 
+    /**
+     * Performs http requests through a fixed list of interceptors. The verbs
+     * return a request builder; `exchange` is the lower-level entry that returns
+     * the Response itself without treating an error status as a failure.
+     */
     class HttpClient {
         #interceptors;
         /**
@@ -357,7 +499,8 @@ var httpc = (function (exports) {
             const is = [...this.#interceptors, ...(interceptors || []), new HttpCall()];
             const chain = new HttpInterceptorChain(is, 0);
             const url = new URL(new Request(uri).url);
-            return await chain.proceed(url, options ?? {});
+            const request = { ...options, headers: new Headers(options?.headers) };
+            return await chain.proceed(url, request);
         }
         /**
          * Creates a request builder.
@@ -419,7 +562,7 @@ var httpc = (function (exports) {
     }
 
     /**
-     *
+     * Reads the response body as the given type, wrapping a failed read as an UNMARSHALING_PROBLEM.
      * @param {Response} response
      * @param {'text'|'json'|'blob'|'arrayBuffer'} type
      * @returns
@@ -452,6 +595,12 @@ var httpc = (function (exports) {
         return Object.entries(source);
     };
 
+    /**
+     * One request under construction: method, url, parameters, headers and body,
+     * with a `fetch*` method per body type. Every configuration method returns the
+     * builder, and a `fetch*` rejects with an HttpClientError for any status
+     * outside 200-299.
+     */
     class HttpRequestBuilder {
         #client;
         #method;
@@ -461,6 +610,7 @@ var httpc = (function (exports) {
         #body;
         #options;
         #interceptors;
+        #fragment;
         /**
          * Creates an HttpRequestBuilder.
          * @param {HttpClient} client
@@ -469,16 +619,22 @@ var httpc = (function (exports) {
          * @returns {HttpRequestBuilder} the builder
          */
         static create(client, method, uri) {
-            const [baseUri, queryString = ''] = uri.split('?');
+            //'/a#frag?p=1' parses as hash '#frag?p=1' with an empty query, and a '?'
+            //may appear in a query itself: only the first of each splits
+            const hashIndex = uri.indexOf('#');
+            const fragment = hashIndex === -1 ? '' : uri.slice(hashIndex);
+            const withoutFragment = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+            const queryIndex = withoutFragment.indexOf('?');
             return new HttpRequestBuilder(
                 client,
                 method,
-                baseUri,
-                new URLSearchParams(queryString),
+                queryIndex === -1 ? withoutFragment : withoutFragment.slice(0, queryIndex),
+                new URLSearchParams(queryIndex === -1 ? '' : withoutFragment.slice(queryIndex + 1)),
                 new Headers(),
                 undefined,
                 {},
                 [],
+                fragment,
             );
         }
         /**
@@ -491,8 +647,9 @@ var httpc = (function (exports) {
          * @param {any} body
          * @param {Omit<RequestInit,"headers"|"method"|"body">} options
          * @param {HttpInterceptor[]} interceptors
+         * @param {string} [fragment]
          */
-        constructor(client, method, uri, params, headers, body, options, interceptors) {
+        constructor(client, method, uri, params, headers, body, options, interceptors, fragment = '') {
             this.#client = client;
             this.#method = method;
             this.#uri = uri;
@@ -501,6 +658,7 @@ var httpc = (function (exports) {
             this.#headers = headers;
             this.#options = options;
             this.#interceptors = interceptors;
+            this.#fragment = fragment;
         }
         /**
          * Add all passed headers to the request, overriding existing ones if that key already exists. Null and undefined values cause the key to be removed.
@@ -547,7 +705,7 @@ var httpc = (function (exports) {
             return this;
         }
         /**
-         * Adds a query parameter to the request, overriding it if it already exists. Empty vs, or a single null or undefined value cause the key to be removed.
+         * Adds a query parameter to the request, overriding it if it already exists. An empty list, or one carrying only null and undefined values, causes the key to be removed; nullish entries among real values are skipped.
          * @param {string} k
          * @param {...string} vs
          * @returns {HttpRequestBuilder} this builder
@@ -556,10 +714,11 @@ var httpc = (function (exports) {
             //overriding, as header, headers and params all do: pass every value in one
             //call to get a multi valued parameter
             this.#params.delete(k);
-            if (vs.length === 0 || vs[0] == null) {
+            const values = vs.filter((v) => v != null);
+            if (values.length === 0) {
                 return this;
             }
-            for (const v of vs) {
+            for (const v of values) {
                 this.#params.append(k, v);
             }
             return this;
@@ -582,8 +741,12 @@ var httpc = (function (exports) {
          * @returns {HttpRequestBuilder} this builder
          */
         json(body) {
+            if (body === undefined) {
+                return this;
+            }
+            const serialized = JSON.stringify(body);
             this.#headers.set('Content-Type', 'application/json');
-            this.#body = JSON.stringify(body);
+            this.#body = serialized;
             return this;
         }
         /**
@@ -621,7 +784,7 @@ var httpc = (function (exports) {
         }
         /**
          * Adds interceptors to the request.
-         * @param {[HttpInterceptor]} is - the interceptor to be regisered
+         * @param {[HttpInterceptor]} is - the interceptor to be registered
          * @returns {HttpRequestBuilder} this builder
          */
         interceptors(is) {
@@ -632,7 +795,7 @@ var httpc = (function (exports) {
         }
         /**
          * Adds an interceptor to the request.
-         * @param {HttpInterceptor} i - the interceptor to be regisered
+         * @param {HttpInterceptor} i - the interceptor to be registered
          * @returns {HttpRequestBuilder} this builder
          */
         interceptor(i) {
@@ -644,29 +807,22 @@ var httpc = (function (exports) {
          * @returns {Promise<Response>} the response
          */
         async exchange() {
-            const uri = this.#params.size ? `${this.#uri}?${this.#params}` : this.#uri;
+            const query = this.#params.size ? `?${this.#params}` : '';
             const opts = {
                 ...this.#options,
                 headers: this.#headers,
                 method: this.#method,
                 body: this.#body,
             };
-            return await this.#client.exchange(uri, opts, this.#interceptors);
+            return await this.#client.exchange(`${this.#uri}${query}${this.#fragment}`, opts, this.#interceptors);
         }
         /**
-         * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+         * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
          * @returns {Promise<Response>} the response
          */
         async fetch() {
-            const uri = this.#params.size ? `${this.#uri}?${this.#params}` : this.#uri;
-            const opts = {
-                ...this.#options,
-                headers: this.#headers,
-                method: this.#method,
-                body: this.#body,
-            };
             try {
-                const response = await this.#client.exchange(uri, opts, this.#interceptors);
+                const response = await this.exchange();
                 if (!response.ok) {
                     throw await HttpClientError.fromResponse(response);
                 }
@@ -675,11 +831,15 @@ var httpc = (function (exports) {
                 if (ex instanceof Failure) {
                     throw ex;
                 }
-                throw HttpClientError.of('CONNECTION_PROBLEM', ex);
+                //fetch() answers a Failure whatever happened, so a caller reading
+                //`problems` never has to test the shape first. What reaches here is
+                //not the transport, which labels its own failure below the chain: it
+                //is a throw from the chain's own code, carried as the cause
+                throw HttpClientError.of('UNEXPECTED_PROBLEM', ex);
             }
         }
         /**
-         * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+         * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
          * @returns {Promise<string>} the response body, as text
          */
         async fetchText() {
@@ -687,15 +847,20 @@ var httpc = (function (exports) {
             return await unmarshal(response, 'text');
         }
         /**
-         * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+         * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
+         * A 204 yields null without reading the body; any other empty body is an unmarshaling failure.
          * @returns {Promise<any>} the response body, deserialized as JSON
          */
         async fetchJson() {
             const response = await this.fetch();
+            if (response.status === 204) {
+                //a 204 declares no content: there is no body to decode
+                return null;
+            }
             return await unmarshal(response, 'json');
         }
         /**
-         * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+         * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
          * @returns {Promise<Blob>} the response body, as a Blob
          */
         async fetchBlob() {
@@ -703,7 +868,7 @@ var httpc = (function (exports) {
             return await unmarshal(response, 'blob');
         }
         /**
-         * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+         * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
          * @returns {Promise<ArrayBuffer>} the response body, as an ArrayBuffer
          */
         async fetchArrayBuffer() {
@@ -712,6 +877,7 @@ var httpc = (function (exports) {
         }
     }
 
+    /** Builds a multipart body: text fields, json parts, and single or repeated blobs. */
     class HttpMultipartRequestCustomizer {
         #formData;
         /**
@@ -777,7 +943,11 @@ var httpc = (function (exports) {
     exports.Failure = Failure;
     exports.Hex = Hex;
     exports.HttpClient = HttpClient;
+    exports.HttpClientBuilder = HttpClientBuilder;
     exports.HttpClientError = HttpClientError;
+    exports.HttpInterceptorChain = HttpInterceptorChain;
+    exports.HttpMultipartRequestCustomizer = HttpMultipartRequestCustomizer;
+    exports.HttpRequestBuilder = HttpRequestBuilder;
     exports.MediaType = MediaType;
 
     return exports;