api-def 0.12.1 → 0.13.0

package/esm/backend/FetchRequestBackend.js

@@ -1,16 +1,7 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { inferResponseType } from "../ApiUtils";
-import { RequestErrorCode, convertToRequestError } from "../RequestError";
-import * as Utils from "../Utils";
-import { getGlobal, getGlobalFetch } from "../Utils";
+import { inferResponseType } from "../ApiUtils.js";
+import { convertToRequestError, RequestErrorCode } from "../RequestError.js";
+import * as Utils from "../Utils.js";
+import { getGlobal, getGlobalFetch } from "../Utils.js";
 class FetchError extends Error {
 }
 export default class FetchRequestBackend {
@@ -25,59 +16,54 @@ export default class FetchRequestBackend {
             }
         }
     }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ("response" in error) {
-                const fetchError = error;
-                return fetchError.response ? fetchError.response : null;
-            }
-            return undefined;
-        });
+    async extractResponseFromError(error) {
+        if ("response" in error) {
+            const fetchError = error;
+            return fetchError.response ? fetchError.response : null;
+        }
+        return undefined;
     }
-    convertResponse(context, response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { status, headers } = response;
-            const convertedResponse = {
-                method: context.method,
-                url: response.url,
-                data: undefined,
-                status: status,
-                headers: headers,
-                state: context.requestConfig.state,
-                stats: context.stats,
-            };
-            const responseType = (_a = context.responseType) !== null && _a !== void 0 ? _a : inferResponseType(response.headers.get("Content-Type"));
-            let text;
-            let data;
-            try {
-                if (responseType === "arraybuffer") {
-                    data = yield response.arrayBuffer();
-                }
-                else if (responseType === "json") {
-                    text = yield response.text();
-                    data = JSON.parse(text);
-                }
-                else if (responseType === "stream") {
-                    data = response.body;
-                }
-                else {
-                    data = yield response.text();
-                }
+    async convertResponse(context, response) {
+        const { status, headers } = response;
+        const convertedResponse = {
+            method: context.method,
+            url: response.url,
+            data: undefined,
+            status: status,
+            headers: headers,
+            state: context.requestConfig.state,
+            stats: context.stats,
+        };
+        const responseType = context.responseType ?? inferResponseType(response.headers.get("Content-Type"));
+        let text;
+        let data;
+        try {
+            if (responseType === "arraybuffer") {
+                data = await response.arrayBuffer();
             }
-            catch (error) {
-                throw convertToRequestError({
-                    error: Object.assign(new Error(`[api-def] Failed to parse response as '${responseType}'${text ? `, got: ${text}` : ""}`), {
-                        cause: error,
-                    }),
-                    code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                    context: context,
-                    response: convertedResponse,
-                });
+            else if (responseType === "json") {
+                text = await response.text();
+                data = JSON.parse(text);
             }
-            convertedResponse.data = data;
-            return convertedResponse;
-        });
+            else if (responseType === "stream") {
+                data = response.body;
+            }
+            else {
+                data = await response.text();
+            }
+        }
+        catch (error) {
+            throw convertToRequestError({
+                error: Object.assign(new Error(`[api-def] Failed to parse response as '${responseType}'${text ? `, got: ${text}` : ""}`), {
+                    cause: error,
+                }),
+                code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                context: context,
+                response: convertedResponse,
+            });
+        }
+        convertedResponse.data = data;
+        return convertedResponse;
     }
     makeRequest(context) {
         if (!this.fetch) {

package/esm/backend/MockRequestBackend.d.ts

@@ -1,7 +1,7 @@
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
-import type { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend";
-import type RequestBackend from "./RequestBackend";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
+import type RequestBackend from "./RequestBackend.js";
+import type { RequestBackendErrorInfo, RequestOperation } from "./RequestBackend.js";
 export default class MockRequestBackend implements RequestBackend<ApiResponse> {
     readonly id = "mock";
     convertResponse<T>(context: RequestContext, response: ApiResponse, error?: boolean): Promise<ApiResponse<T>>;

package/esm/backend/MockRequestBackend.js

@@ -1,151 +1,120 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-import { inferResponseType } from "../ApiUtils";
-import { RequestErrorCode, convertToRequestError } from "../RequestError";
-import * as Utils from "../Utils";
-import { delayThenReturn, randInt } from "../Utils";
+import { inferResponseType } from "../ApiUtils.js";
+import { convertToRequestError, RequestErrorCode } from "../RequestError.js";
+import * as Utils from "../Utils.js";
+import { delayThenReturn, randInt } from "../Utils.js";
 export default class MockRequestBackend {
     constructor() {
         this.id = "mock";
     }
-    convertResponse(context, response, error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return response;
-        });
+    async convertResponse(context, response, error) {
+        return response;
     }
-    extractResponseFromError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ("response" in error) {
-                const fetchError = error;
-                return fetchError.response ? fetchError.response : null;
-            }
-            return undefined;
-        });
+    async extractResponseFromError(error) {
+        if ("response" in error) {
+            const fetchError = error;
+            return fetchError.response ? fetchError.response : null;
+        }
+        return undefined;
     }
-    runRequest(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f;
-            const mockingFunc = (_a = context.mocking) === null || _a === void 0 ? void 0 : _a.handler;
-            if (!mockingFunc) {
-                throw convertToRequestError({
-                    error: new Error("[api-def] Attempted to run mocked request without mocking function"),
-                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                    context,
-                });
-            }
-            const req = {
-                body: context.getParsedBody(),
-                params: (_b = context.requestConfig.params) !== null && _b !== void 0 ? _b : {},
-                query: context.requestConfig.queryObject,
-                headers: (_c = context.requestConfig.headers) !== null && _c !== void 0 ? _c : {},
-                url: context.requestUrl.toString(),
-                state: context.requestConfig.state,
-            };
-            const res = {
-                statusCode: -1,
-                headers: {},
-                response: undefined,
-                status(statusCode) {
-                    res.statusCode = statusCode;
-                    return res;
-                },
-                send(response) {
-                    res.response = response;
-                    if (response && typeof response === "object") {
-                        res.headers["Content-Type"] = "application/json";
-                    }
-                    return res;
-                },
-            };
-            if ((_d = context.mocking) === null || _d === void 0 ? void 0 : _d.delay) {
-                const delay = context.mocking.delay;
-                let delayMs;
-                if (typeof delay === "number") {
-                    delayMs = delay;
-                }
-                else {
-                    const [min, max] = delay;
-                    if (min > max) {
-                        throw convertToRequestError({
-                            error: new Error("[api-def] Min delay cannot be greater than max delay"),
-                            code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                            context,
-                        });
-                    }
-                    delayMs = randInt(min, max);
+    async runRequest(context) {
+        const mockingFunc = context.mocking?.handler;
+        if (!mockingFunc) {
+            throw convertToRequestError({
+                error: new Error("[api-def] Attempted to run mocked request without mocking function"),
+                code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                context,
+            });
+        }
+        const req = {
+            body: context.getParsedBody(),
+            params: context.requestConfig.params ?? {},
+            query: context.requestConfig.queryObject,
+            headers: context.requestConfig.headers ?? {},
+            url: context.requestUrl.toString(),
+            state: context.requestConfig.state,
+        };
+        const res = {
+            statusCode: -1,
+            headers: {},
+            response: undefined,
+            status(statusCode) {
+                res.statusCode = statusCode;
+                return res;
+            },
+            send(response) {
+                res.response = response;
+                if (response && typeof response === "object") {
+                    res.headers["Content-Type"] = "application/json";
                 }
-                yield delayThenReturn(yield mockingFunc(req, res), delayMs);
+                return res;
+            },
+        };
+        if (context.mocking?.delay) {
+            const delay = context.mocking.delay;
+            let delayMs;
+            if (typeof delay === "number") {
+                delayMs = delay;
             }
             else {
-                yield mockingFunc(req, res);
-            }
-            if (res.response === undefined) {
-                throw convertToRequestError({
-                    error: new Error("[api-def] Mocked API did not respond"),
-                    code: RequestErrorCode.REQUEST_INVALID_CONFIG,
-                    context,
-                });
+                const [min, max] = delay;
+                if (min > max) {
+                    throw convertToRequestError({
+                        error: new Error("[api-def] Min delay cannot be greater than max delay"),
+                        code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                        context,
+                    });
+                }
+                delayMs = randInt(min, max);
             }
-            const parsedHeaders = Object.keys(res.headers).reduce((parsedHeaders, key) => {
-                parsedHeaders.set(key, res.headers[key].toString());
-                return parsedHeaders;
-            }, new Headers());
-            const responseType = (_e = context.responseType) !== null && _e !== void 0 ? _e : inferResponseType((_f = res.headers["content-type"]) === null || _f === void 0 ? void 0 : _f.toString());
-            let data;
-            if (responseType === "stream") {
-                // For streaming responses, we create a mock async iterator
-                data = {
-                    [Symbol.asyncIterator]() {
-                        return __asyncGenerator(this, arguments, function* _a() {
-                            if (res.response) {
-                                // If the response is an array, yield each item
-                                if (Array.isArray(res.response)) {
-                                    for (const item of res.response) {
-                                        yield yield __await(new TextEncoder().encode(`${JSON.stringify(item)}\n`));
-                                    }
-                                }
-                                else {
-                                    // Otherwise yield the entire response
-                                    yield yield __await(new TextEncoder().encode(`${JSON.stringify(res.response)}\n`));
-                                }
+            await delayThenReturn(await mockingFunc(req, res), delayMs);
+        }
+        else {
+            await mockingFunc(req, res);
+        }
+        if (res.response === undefined) {
+            throw convertToRequestError({
+                error: new Error("[api-def] Mocked API did not respond"),
+                code: RequestErrorCode.REQUEST_INVALID_CONFIG,
+                context,
+            });
+        }
+        const parsedHeaders = Object.keys(res.headers).reduce((parsedHeaders, key) => {
+            parsedHeaders.set(key, res.headers[key].toString());
+            return parsedHeaders;
+        }, new Headers());
+        const responseType = context.responseType ?? inferResponseType(res.headers["content-type"]?.toString());
+        let data;
+        if (responseType === "stream") {
+            // For streaming responses, we create a mock async iterator
+            data = {
+                async *[Symbol.asyncIterator]() {
+                    if (res.response) {
+                        // If the response is an array, yield each item
+                        if (Array.isArray(res.response)) {
+                            for (const item of res.response) {
+                                yield new TextEncoder().encode(`${JSON.stringify(item)}\n`);
                             }
-                        });
-                    },
-                };
-            }
-            else {
-                data = res.response;
-            }
-            return {
-                url: context.requestUrl.href,
-                method: context.method,
-                headers: parsedHeaders,
-                data: data,
-                status: res.statusCode,
-                state: context.requestConfig.state,
-                stats: context.stats,
+                        }
+                        else {
+                            // Otherwise yield the entire response
+                            yield new TextEncoder().encode(`${JSON.stringify(res.response)}\n`);
+                        }
+                    }
+                },
             };
-        });
+        }
+        else {
+            data = res.response;
+        }
+        return {
+            url: context.requestUrl.href,
+            method: context.method,
+            headers: parsedHeaders,
+            data: data,
+            status: res.statusCode,
+            state: context.requestConfig.state,
+            stats: context.stats,
+        };
     }
     makeRequest(context) {
         return {

package/esm/backend/RequestBackend.d.ts

@@ -1,5 +1,5 @@
-import type { ApiResponse } from "../ApiTypes";
-import type RequestContext from "../RequestContext";
+import type { ApiResponse } from "../ApiTypes.js";
+import type RequestContext from "../RequestContext.js";
 export interface RequestOperation<R> {
     promise: Promise<R>;
     canceler: () => void;

package/esm/cache/ClientCaching.d.ts

@@ -1,4 +1,4 @@
-import type { ClientCacheBackend } from "./ClientCacheBackend";
+import type { ClientCacheBackend } from "./ClientCacheBackend.js";
 export declare const setClientCacheBackend: (backend: ClientCacheBackend) => void;
 export declare const DEFAULT_CLIENT_CACHE_EXPIRY: number;
 export declare const clearClientCache: () => Promise<void>;

package/esm/cache/ClientCaching.js

@@ -1,13 +1,4 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import LocalStorageClientCacheBackend from "./LocalStorageClientCacheBackend";
+import LocalStorageClientCacheBackend from "./LocalStorageClientCacheBackend.js";
 let clientCacheBackend = new LocalStorageClientCacheBackend();
 export const setClientCacheBackend = (backend) => {
     clientCacheBackend = backend;
@@ -16,24 +7,24 @@ export const DEFAULT_CLIENT_CACHE_EXPIRY = /* 15 mins */ 60 * 1000 * 15;
 export const clearClientCache = () => {
     return clientCacheBackend.clear();
 };
-export const setClientCachedItem = (key, value, expiry) => __awaiter(void 0, void 0, void 0, function* () {
+export const setClientCachedItem = async (key, value, expiry) => {
     const entry = {
         data: value,
         expiry: expiry === undefined || Number.isNaN(expiry) ? null : expiry,
     };
-    yield clientCacheBackend.setItem(key, entry);
+    await clientCacheBackend.setItem(key, entry);
     return value;
-});
-export const getClientCachedItem = (key) => __awaiter(void 0, void 0, void 0, function* () {
-    const entry = yield clientCacheBackend.getItem(key);
+};
+export const getClientCachedItem = async (key) => {
+    const entry = await clientCacheBackend.getItem(key);
     if (!entry) {
         return undefined;
     }
     if (typeof entry.expiry === "number") {
         if (Date.now() >= entry.expiry) {
-            yield clientCacheBackend.removeItem(key);
+            await clientCacheBackend.removeItem(key);
             return undefined;
         }
     }
     return entry.data;
-});
+};

package/esm/cache/LocalForageClientCacheBackend.d.ts

@@ -1,4 +1,4 @@
-import type { ClientCacheBackend } from "./ClientCacheBackend";
+import type { ClientCacheBackend } from "./ClientCacheBackend.js";
 export default class LocalForageClientCacheBackend implements ClientCacheBackend {
     private store;
     constructor(localforage: any);

package/esm/cache/LocalForageClientCacheBackend.js

@@ -1,36 +1,19 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export default class LocalForageClientCacheBackend {
     constructor(localforage) {
         this.store = localforage.createInstance({
             name: "requestClientCache",
         });
     }
-    getItem(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.store.getItem(key);
-        });
+    async getItem(key) {
+        return this.store.getItem(key);
     }
-    setItem(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.store.setItem(key, value);
-        });
+    async setItem(key, value) {
+        await this.store.setItem(key, value);
     }
-    removeItem(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.store.removeItem(key);
-        });
+    async removeItem(key) {
+        await this.store.removeItem(key);
     }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.store.clear();
-        });
+    async clear() {
+        await this.store.clear();
     }
 }

package/esm/cache/LocalStorageClientCacheBackend.d.ts

@@ -1,4 +1,4 @@
-import type { ClientCacheBackend } from "./ClientCacheBackend";
+import type { ClientCacheBackend } from "./ClientCacheBackend.js";
 export default class LocalStorageClientCacheBackend implements ClientCacheBackend {
     getItem(key: string): Promise<any>;
     setItem(key: string, value: any): Promise<void>;

package/esm/cache/LocalStorageClientCacheBackend.js

@@ -1,32 +1,15 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export default class LocalStorageClientCacheBackend {
-    getItem(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const item = localStorage.getItem(key);
-            return item ? JSON.parse(item) : null;
-        });
+    async getItem(key) {
+        const item = localStorage.getItem(key);
+        return item ? JSON.parse(item) : null;
     }
-    setItem(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            localStorage.setItem(key, JSON.stringify(value));
-        });
+    async setItem(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
     }
-    removeItem(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            localStorage.removeItem(key);
-        });
+    async removeItem(key) {
+        localStorage.removeItem(key);
     }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            localStorage.clear();
-        });
+    async clear() {
+        localStorage.clear();
     }
 }

package/esm/index.d.ts

@@ -1,17 +1,17 @@
-export * from "./Api";
-export * from "./ApiTypes";
-export * from "./UtilTypes";
-export * from "./ApiConstants";
-export { default as retry } from "./util/retry";
+export * from "./Api.js";
+export * from "./ApiConstants.js";
+export * from "./ApiTypes.js";
+export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend.js";
+export { default as FetchRequestBackend } from "./backend/FetchRequestBackend.js";
+export { default as RequestBackend } from "./backend/RequestBackend.js";
+export { clearClientCache, setClientCacheBackend } from "./cache/ClientCaching.js";
+export { default as LocalForageClientCacheBackend } from "./cache/LocalForageClientCacheBackend.js";
+export { default as LocalStorageClientCacheBackend } from "./cache/LocalStorageClientCacheBackend.js";
+export { default as Endpoint, type EndpointConfig } from "./Endpoint.js";
+export { default as EndpointBuilder, type EndpointBuildOptions } from "./EndpointBuilder.js";
+export { default as ClientCacheMiddleware } from "./middleware/ClientCacheMiddleware.js";
+export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware.js";
+export { getErrorResponse, isRequestError, type RequestError } from "./RequestError.js";
+export * from "./UtilTypes.js";
+export { default as retry } from "./util/retry/index.js";
 export type { RetryOptions } from "./util/retry/interfaces";
-export { isRequestError, getErrorResponse, type RequestError } from "./RequestError";
-export { default as Endpoint, type EndpointConfig } from "./Endpoint";
-export { default as EndpointBuilder, type EndpointBuildOptions } from "./EndpointBuilder";
-export { clearClientCache, setClientCacheBackend } from "./cache/ClientCaching";
-export { default as LocalStorageClientCacheBackend } from "./cache/LocalStorageClientCacheBackend";
-export { default as LocalForageClientCacheBackend } from "./cache/LocalForageClientCacheBackend";
-export { default as RequestBackend } from "./backend/RequestBackend";
-export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
-export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
-export { default as ClientCacheMiddleware } from "./middleware/ClientCacheMiddleware";
-export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";

package/esm/index.js

@@ -1,16 +1,16 @@
 /// <reference types="typescript" />
-export * from "./Api";
-export * from "./ApiTypes";
-export * from "./UtilTypes";
-export * from "./ApiConstants";
-export { default as retry } from "./util/retry";
-export { isRequestError, getErrorResponse } from "./RequestError";
-export { default as Endpoint } from "./Endpoint";
-export { default as EndpointBuilder } from "./EndpointBuilder";
-export { clearClientCache, setClientCacheBackend } from "./cache/ClientCaching";
-export { default as LocalStorageClientCacheBackend } from "./cache/LocalStorageClientCacheBackend";
-export { default as LocalForageClientCacheBackend } from "./cache/LocalForageClientCacheBackend";
-export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend";
-export { default as FetchRequestBackend } from "./backend/FetchRequestBackend";
-export { default as ClientCacheMiddleware } from "./middleware/ClientCacheMiddleware";
-export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware";
+export * from "./Api.js";
+export * from "./ApiConstants.js";
+export * from "./ApiTypes.js";
+export { default as AxiosRequestBackend } from "./backend/AxiosRequestBackend.js";
+export { default as FetchRequestBackend } from "./backend/FetchRequestBackend.js";
+export { clearClientCache, setClientCacheBackend } from "./cache/ClientCaching.js";
+export { default as LocalForageClientCacheBackend } from "./cache/LocalForageClientCacheBackend.js";
+export { default as LocalStorageClientCacheBackend } from "./cache/LocalStorageClientCacheBackend.js";
+export { default as Endpoint } from "./Endpoint.js";
+export { default as EndpointBuilder } from "./EndpointBuilder.js";
+export { default as ClientCacheMiddleware } from "./middleware/ClientCacheMiddleware.js";
+export { default as LoggingMiddleware } from "./middleware/LoggingMiddleware.js";
+export { getErrorResponse, isRequestError } from "./RequestError.js";
+export * from "./UtilTypes.js";
+export { default as retry } from "./util/retry/index.js";