@marianmeres/http-utils 2.1.0 → 2.3.0

package/AGENTS.md

@@ -103,6 +103,13 @@ HTTP_ERROR.BadGateway       // 502
 HTTP_ERROR.ServiceUnavailable // 503
 ```
 
+### Helper Functions
+
+```typescript
+// Marks options object for options-based API (vs legacy positional API)
+function opts<T extends GetOptions | DataOptions>(options: T): T
+```
+
 ### Utility Functions
 
 ```typescript
@@ -168,12 +175,18 @@ deno task publish     # Publish to JSR and NPM
 ### Basic Usage
 
 ```typescript
+import { createHttpApi, opts } from "@marianmeres/http-utils";
+
 const api = createHttpApi("https://api.example.com", {
   headers: { "Authorization": "Bearer token" }
 });
 
+// Legacy API (default - object is request body)
 const data = await api.get("/users");
-await api.post("/users", { data: { name: "John" } });
+await api.post("/users", { name: "John" });
+
+// Options API (requires opts() wrapper)
+await api.post("/users", opts({ data: { name: "John" }, params: { token: "abc" } }));
 ```
 
 ### Error Handling

package/API.md

@@ -5,6 +5,7 @@ Complete API reference for `@marianmeres/http-utils`.
 ## Table of Contents
 
 - [createHttpApi](#createhttpapi)
+- [opts](#opts)
 - [HttpApi Class](#httpapi-class)
 - [Types](#types)
 - [HTTP Errors](#http-errors)
@@ -78,86 +79,132 @@ Priority order: per-request > per-instance > global > built-in fallback.
 
 ---
 
+## opts
+
+Marks an options object for the options-based API. Without this wrapper, arguments are treated as legacy positional parameters.
+
+```ts
+function opts<T extends GetOptions | DataOptions>(options: T): T
+```
+
+### Why `opts()`?
+
+The library supports two API styles:
+- **Legacy API**: Positional parameters (backward compatible)
+- **Options API**: Single options object with named properties
+
+The `opts()` wrapper explicitly indicates which style you're using, preventing ambiguity when your request data might look like an options object.
+
+### Example
+
+```ts
+import { createHttpApi, opts } from "@marianmeres/http-utils";
+
+const api = createHttpApi("https://api.example.com");
+
+// Without opts() - legacy behavior: entire object is sent as request body
+await api.post("/users", { data: { name: "John" } });
+// Sends: { "data": { "name": "John" } }
+
+// With opts() - options API: data is extracted and sent as body
+await api.post("/users", opts({ data: { name: "John" } }));
+// Sends: { "name": "John" }
+
+// GET with options
+const respHeaders = {};
+await api.get("/users", opts({
+  params: { headers: { "X-Custom": "value" } },
+  respHeaders
+}));
+```
+
+---
+
 ## HttpApi Class
 
 HTTP API client class. Usually created via `createHttpApi()`.
 
 ### Methods
 
-#### `get(path, options?)`
+#### `get<T>(path, options?)`
 
 Performs a GET request.
 
-**New Options API (recommended):**
+**Options API (with `opts()` wrapper):**
 ```ts
-async get(path: string, options?: GetOptions): Promise<unknown>
+async get<T = unknown>(path: string, options?: GetOptions): Promise<T>
 ```
 
-**Legacy API:**
+**Legacy API (default behavior):**
 ```ts
-async get(
+async get<T = unknown>(
   path: string,
   params?: FetchParams,
   respHeaders?: ResponseHeaders | null,
   errorMessageExtractor?: ErrorMessageExtractor | null
-): Promise<unknown>
+): Promise<T>
 ```
 
 **Example:**
 ```ts
-// New API
-const data = await api.get("/users", {
+// Options API with type parameter (requires opts() wrapper)
+interface User { id: number; name: string; }
+const user = await api.get<User>("/users/1", opts({
   params: { headers: { "X-Custom": "value" } },
   respHeaders: {}
-});
+}));
+
+// Without type parameter (returns unknown)
+const data = await api.get("/users");
 
-// Legacy API
+// Legacy API (no opts() needed)
 const data = await api.get("/users", { headers: { "X-Custom": "value" } });
 ```
 
-#### `post(path, options?)`
+#### `post<T>(path, options?)`
 
 Performs a POST request.
 
-**New Options API (recommended):**
+**Options API (with `opts()` wrapper):**
 ```ts
-async post(path: string, options?: DataOptions): Promise<unknown>
+async post<T = unknown>(path: string, options?: DataOptions): Promise<T>
 ```
 
-**Legacy API:**
+**Legacy API (default behavior):**
 ```ts
-async post(
+async post<T = unknown>(
   path: string,
   data?: RequestData,
   params?: FetchParams,
   respHeaders?: ResponseHeaders | null,
   errorMessageExtractor?: ErrorMessageExtractor | null
-): Promise<unknown>
+): Promise<T>
 ```
 
 **Example:**
 ```ts
-// New API
-const result = await api.post("/users", {
+// Options API with type parameter (requires opts() wrapper)
+interface User { id: number; name: string; }
+const user = await api.post<User>("/users", opts({
   data: { name: "John" },
   params: { headers: { "X-Custom": "value" } }
-});
+}));
 
-// Legacy API
+// Legacy API (no opts() needed)
 const result = await api.post("/users", { name: "John" });
 ```
 
-#### `put(path, options?)`
+#### `put<T>(path, options?)`
 
-Performs a PUT request. Same signature as `post()`.
+Performs a PUT request. Same signature as `post<T>()`.
 
-#### `patch(path, options?)`
+#### `patch<T>(path, options?)`
 
-Performs a PATCH request. Same signature as `post()`.
+Performs a PATCH request. Same signature as `post<T>()`.
 
-#### `del(path, options?)`
+#### `del<T>(path, options?)`
 
-Performs a DELETE request. Same signature as `post()`.
+Performs a DELETE request. Same signature as `post<T>()`.
 
 #### `url(path)`
 

package/README.md

@@ -13,6 +13,7 @@ Opinionated, lightweight HTTP client wrapper for `fetch` with type-safe errors a
 - 🪶 **Lightweight** - Zero dependencies, thin wrapper over native `fetch`
 - 🎨 **Flexible error handling** - Three-tier error message extraction (local → factory → global)
 - 📦 **Deno & Node.js** - Works in both runtimes
+- 🦾 **Generic return types** - Optional type parameters for typed responses
 
 ## Installation
 
@@ -25,34 +26,39 @@ npm install @marianmeres/http-utils
 ```
 
 ```ts
-import { createHttpApi, HTTP_ERROR } from "@marianmeres/http-utils";
+import { createHttpApi, opts, HTTP_ERROR } from "@marianmeres/http-utils";
 ```
 
 ## Quick Start
 
 ```ts
-import { createHttpApi, HTTP_ERROR, NotFound } from "@marianmeres/http-utils";
+import { createHttpApi, opts, HTTP_ERROR, NotFound } from "@marianmeres/http-utils";
 
 // Create an API client with base URL
 const api = createHttpApi("https://api.example.com", {
   headers: { "Authorization": "Bearer your-token" }
 });
 
-// GET request (new options API - recommended)
-const users = await api.get("/users", {
+// GET request (options API with opts() wrapper)
+const users = await api.get("/users", opts({
   params: { headers: { "X-Custom": "value" } }
-});
+}));
 
-// POST request (new options API - recommended)
-const newUser = await api.post("/users", {
+// POST request (options API with opts() wrapper)
+const newUser = await api.post("/users", opts({
   data: { name: "John Doe" },
   params: { headers: { "X-Custom": "value" } }
-});
+}));
 
-// Legacy API still works
+// Legacy API (default behavior without opts())
 const legacyUsers = await api.get("/users", { headers: { "X-Custom": "value" } });
 const legacyUser = await api.post("/users", { name: "John Doe" });
 
+// With type parameters for typed responses
+interface User { id: number; name: string; }
+const user = await api.get<User>("/users/1");
+const created = await api.post<User>("/users", opts({ data: { name: "Jane" } }));
+
 // Error handling
 try {
   await api.get("/not-found");
@@ -83,23 +89,37 @@ const api = createHttpApi("https://api.example.com", {
 ### HTTP Methods
 
 ```ts
-// GET (new options API)
-const data = await api.get("/users", {
+// GET (options API with opts() wrapper)
+const data = await api.get("/users", opts({
   params: { headers: { "X-Custom": "value" } },
   respHeaders: {}
-});
+}));
 
-// POST/PUT/PATCH/DELETE (new options API)
-await api.post("/users", {
+// POST/PUT/PATCH/DELETE (options API with opts() wrapper)
+await api.post("/users", opts({
   data: { name: "John" },
   params: { token: "bearer-token" }
-});
+}));
 
-// Legacy API still supported
+// Legacy API (default behavior without opts())
 const data = await api.get("/users", { headers: { "X-Custom": "value" } });
 await api.post("/users", { name: "John" });
 ```
 
+### The `opts()` Helper
+
+The `opts()` function explicitly marks an options object for the options-based API. Without it, arguments are treated as legacy positional parameters.
+
+```ts
+// Without opts() - legacy behavior: object is sent as request body
+await api.post("/users", { data: { name: "John" } });  // Sends: { data: { name: "John" } }
+
+// With opts() - options API: data is extracted and sent as body
+await api.post("/users", opts({ data: { name: "John" } }));  // Sends: { name: "John" }
+```
+
+This makes the API unambiguous and prevents accidental misinterpretation of request data.
+
 ### Error Handling
 
 ```ts
@@ -123,6 +143,7 @@ try {
 - **Raw response**: Use `raw: true` to get the raw Response object
 - **Non-throwing**: Use `assert: false` to prevent throwing on errors
 - **AbortController**: Pass `signal` for request cancellation
+- **Typed responses**: Use generics for type-safe responses: `api.get<User>("/users/1")`
 
 ## Full API Reference
 

package/dist/api.d.ts

@@ -71,6 +71,20 @@ export interface DataOptions {
     /** Custom error message extractor for this request. */
     errorExtractor?: ErrorMessageExtractor | null;
 }
+/**
+ * Marks an options object for the new options API.
+ * Use this to explicitly indicate you're using the options-based API.
+ *
+ * @example
+ * ```ts
+ * // GET with options
+ * await api.get('/users', opts({ params: { token: 'abc' } }));
+ *
+ * // POST with options
+ * await api.post('/users', opts({ data: { name: 'John' }, params: { token: 'abc' } }));
+ * ```
+ */
+export declare function opts<T extends GetOptions | DataOptions>(options: T): T;
 /**
  * HTTP API client with convenient defaults and error handling.
  */
@@ -93,7 +107,7 @@ export declare class HttpApi {
      * });
      * ```
      */
-    get(path: string, options: GetOptions): Promise<unknown>;
+    get<T = unknown>(path: string, options: GetOptions): Promise<T>;
     /**
      * Performs a GET request (legacy API).
      *
@@ -105,7 +119,7 @@ export declare class HttpApi {
      * @returns The response body (auto-parsed as JSON if possible), or Response if `raw: true`.
      * @throws {HttpError} When the response is not OK and `assert` is true (default).
      */
-    get(path: string, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<unknown>;
+    get<T = unknown>(path: string, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<T>;
     /**
      * Performs a POST request (new options API - recommended).
      *
@@ -123,7 +137,7 @@ export declare class HttpApi {
      * });
      * ```
      */
-    post(path: string, options: DataOptions): Promise<unknown>;
+    post<T = unknown>(path: string, options: DataOptions): Promise<T>;
     /**
      * Performs a POST request (legacy API).
      *
@@ -136,23 +150,23 @@ export declare class HttpApi {
      * @returns The response body (auto-parsed as JSON if possible), or Response if `raw: true`.
      * @throws {HttpError} When the response is not OK and `assert` is true (default).
      */
-    post(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<unknown>;
+    post<T = unknown>(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<T>;
     /** Performs a PUT request (new options API). @see post */
-    put(path: string, options: DataOptions): Promise<unknown>;
+    put<T = unknown>(path: string, options: DataOptions): Promise<T>;
     /** Performs a PUT request (legacy API). @see post */
-    put(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<unknown>;
+    put<T = unknown>(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<T>;
     /** Performs a PATCH request (new options API). @see post */
-    patch(path: string, options: DataOptions): Promise<unknown>;
+    patch<T = unknown>(path: string, options: DataOptions): Promise<T>;
     /** Performs a PATCH request (legacy API). @see post */
-    patch(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<unknown>;
+    patch<T = unknown>(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<T>;
     /**
      * Performs a DELETE request (new options API).
      * Note: Request body in DELETE is allowed per HTTP spec.
      * @see post
      */
-    del(path: string, options: DataOptions): Promise<unknown>;
+    del<T = unknown>(path: string, options: DataOptions): Promise<T>;
     /** Performs a DELETE request (legacy API). @see post */
-    del(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<unknown>;
+    del<T = unknown>(path: string, data?: RequestData, params?: FetchParams, respHeaders?: ResponseHeaders | null, errorMessageExtractor?: ErrorMessageExtractor | null, _dumpParams?: boolean): Promise<T>;
     /**
      * Helper method to build the full URL from a path.
      *

package/dist/api.js

@@ -32,6 +32,68 @@ function deepMerge(target, source) {
 function isObject(item) {
     return item !== null && typeof item === 'object' && !Array.isArray(item);
 }
+/** Symbol marker for explicit options API detection. */
+const OPTIONS_MARKER = Symbol('options');
+/**
+ * Marks an options object for the new options API.
+ * Use this to explicitly indicate you're using the options-based API.
+ *
+ * @example
+ * ```ts
+ * // GET with options
+ * await api.get('/users', opts({ params: { token: 'abc' } }));
+ *
+ * // POST with options
+ * await api.post('/users', opts({ data: { name: 'John' }, params: { token: 'abc' } }));
+ * ```
+ */
+export function opts(options) {
+    return Object.assign(options, { [OPTIONS_MARKER]: true });
+}
+/**
+ * Parses GET method arguments, detecting new options API via OPTIONS_MARKER.
+ */
+function parseGetOptions(paramsOrOptions, legacyRespHeaders, legacyErrorExtractor) {
+    if (paramsOrOptions && OPTIONS_MARKER in paramsOrOptions) {
+        // New options API (explicit via opts() wrapper)
+        const o = paramsOrOptions;
+        return {
+            params: o.params,
+            respHeaders: o.respHeaders ?? null,
+            errorExtractor: o.errorExtractor ?? null,
+        };
+    }
+    // Legacy positional API
+    return {
+        params: paramsOrOptions,
+        respHeaders: legacyRespHeaders ?? null,
+        errorExtractor: legacyErrorExtractor ?? null,
+    };
+}
+/**
+ * Parses body method arguments (POST/PUT/PATCH/DELETE), detecting new options API via OPTIONS_MARKER.
+ */
+function parseDataOptions(dataOrOptions, legacyParams, legacyRespHeaders, legacyErrorExtractor) {
+    if (dataOrOptions &&
+        typeof dataOrOptions === 'object' &&
+        OPTIONS_MARKER in dataOrOptions) {
+        // New options API (explicit via opts() wrapper)
+        const o = dataOrOptions;
+        return {
+            data: o.data ?? null,
+            params: o.params,
+            respHeaders: o.respHeaders ?? null,
+            errorExtractor: o.errorExtractor ?? null,
+        };
+    }
+    // Legacy positional API
+    return {
+        data: dataOrOptions ?? null,
+        params: legacyParams,
+        respHeaders: legacyRespHeaders ?? null,
+        errorExtractor: legacyErrorExtractor ?? null,
+    };
+}
 const _fetchRaw = async ({ method, path, data = null, token = null, headers = null, signal, credentials, }) => {
     const normalizedHeaders = Object.entries(headers || {}).reduce((m, [k, v]) => ({ ...m, [k.toLowerCase()]: v }), {});
     const opts = {
@@ -142,136 +204,29 @@ export class HttpApi {
         return /^https?:/.test(path) ? path : base + path;
     }
     async get(path, paramsOrOptions, respHeaders, errorMessageExtractor, _dumpParams = false) {
-        // Detect which API is being used
-        let params;
-        let headers = null;
-        let extractor = null;
-        if (paramsOrOptions && ('respHeaders' in paramsOrOptions || 'errorExtractor' in paramsOrOptions)) {
-            // New options API
-            const opts = paramsOrOptions;
-            params = opts.params;
-            headers = opts.respHeaders ?? null;
-            extractor = opts.errorExtractor ?? null;
-        }
-        else {
-            // Legacy positional API
-            params = paramsOrOptions;
-            headers = respHeaders ?? null;
-            extractor = errorMessageExtractor ?? null;
-        }
+        const { params, respHeaders: headers, errorExtractor } = parseGetOptions(paramsOrOptions, respHeaders, errorMessageExtractor);
         path = this.#buildPath(path, this.#base);
-        return _fetch(this.#merge(await this.#getDefs(), { ...params, method: 'GET', path }), headers, extractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
+        return _fetch(this.#merge(await this.#getDefs(), { ...params, method: 'GET', path }), headers, errorExtractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
     }
     async post(path, dataOrOptions, params, respHeaders, errorMessageExtractor, _dumpParams = false) {
-        // Detect which API is being used
-        let data = null;
-        let fetchParams;
-        let headers = null;
-        let extractor = null;
-        if (dataOrOptions &&
-            typeof dataOrOptions === 'object' &&
-            !(dataOrOptions instanceof FormData) &&
-            ('data' in dataOrOptions ||
-                'params' in dataOrOptions ||
-                'respHeaders' in dataOrOptions ||
-                'errorExtractor' in dataOrOptions)) {
-            // New options API
-            const opts = dataOrOptions;
-            data = opts.data ?? null;
-            fetchParams = opts.params;
-            headers = opts.respHeaders ?? null;
-            extractor = opts.errorExtractor ?? null;
-        }
-        else {
-            // Legacy positional API
-            data = dataOrOptions ?? null;
-            fetchParams = params;
-            headers = respHeaders ?? null;
-            extractor = errorMessageExtractor ?? null;
-        }
+        const { data, params: fetchParams, respHeaders: headers, errorExtractor } = parseDataOptions(dataOrOptions, params, respHeaders, errorMessageExtractor);
         path = this.#buildPath(path, this.#base);
-        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'POST', path }), headers, extractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
+        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'POST', path }), headers, errorExtractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
     }
     async put(path, dataOrOptions, params, respHeaders, errorMessageExtractor, _dumpParams = false) {
-        let data = null;
-        let fetchParams;
-        let headers = null;
-        let extractor = null;
-        if (dataOrOptions &&
-            typeof dataOrOptions === 'object' &&
-            !(dataOrOptions instanceof FormData) &&
-            ('data' in dataOrOptions ||
-                'params' in dataOrOptions ||
-                'respHeaders' in dataOrOptions ||
-                'errorExtractor' in dataOrOptions)) {
-            const opts = dataOrOptions;
-            data = opts.data ?? null;
-            fetchParams = opts.params;
-            headers = opts.respHeaders ?? null;
-            extractor = opts.errorExtractor ?? null;
-        }
-        else {
-            data = dataOrOptions ?? null;
-            fetchParams = params;
-            headers = respHeaders ?? null;
-            extractor = errorMessageExtractor ?? null;
-        }
+        const { data, params: fetchParams, respHeaders: headers, errorExtractor } = parseDataOptions(dataOrOptions, params, respHeaders, errorMessageExtractor);
         path = this.#buildPath(path, this.#base);
-        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'PUT', path }), headers, extractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
+        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'PUT', path }), headers, errorExtractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
     }
     async patch(path, dataOrOptions, params, respHeaders, errorMessageExtractor, _dumpParams = false) {
-        let data = null;
-        let fetchParams;
-        let headers = null;
-        let extractor = null;
-        if (dataOrOptions &&
-            typeof dataOrOptions === 'object' &&
-            !(dataOrOptions instanceof FormData) &&
-            ('data' in dataOrOptions ||
-                'params' in dataOrOptions ||
-                'respHeaders' in dataOrOptions ||
-                'errorExtractor' in dataOrOptions)) {
-            const opts = dataOrOptions;
-            data = opts.data ?? null;
-            fetchParams = opts.params;
-            headers = opts.respHeaders ?? null;
-            extractor = opts.errorExtractor ?? null;
-        }
-        else {
-            data = dataOrOptions ?? null;
-            fetchParams = params;
-            headers = respHeaders ?? null;
-            extractor = errorMessageExtractor ?? null;
-        }
+        const { data, params: fetchParams, respHeaders: headers, errorExtractor } = parseDataOptions(dataOrOptions, params, respHeaders, errorMessageExtractor);
         path = this.#buildPath(path, this.#base);
-        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'PATCH', path }), headers, extractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
+        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'PATCH', path }), headers, errorExtractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
     }
     async del(path, dataOrOptions, params, respHeaders, errorMessageExtractor, _dumpParams = false) {
-        let data = null;
-        let fetchParams;
-        let headers = null;
-        let extractor = null;
-        if (dataOrOptions &&
-            typeof dataOrOptions === 'object' &&
-            !(dataOrOptions instanceof FormData) &&
-            ('data' in dataOrOptions ||
-                'params' in dataOrOptions ||
-                'respHeaders' in dataOrOptions ||
-                'errorExtractor' in dataOrOptions)) {
-            const opts = dataOrOptions;
-            data = opts.data ?? null;
-            fetchParams = opts.params;
-            headers = opts.respHeaders ?? null;
-            extractor = opts.errorExtractor ?? null;
-        }
-        else {
-            data = dataOrOptions ?? null;
-            fetchParams = params;
-            headers = respHeaders ?? null;
-            extractor = errorMessageExtractor ?? null;
-        }
+        const { data, params: fetchParams, respHeaders: headers, errorExtractor } = parseDataOptions(dataOrOptions, params, respHeaders, errorMessageExtractor);
         path = this.#buildPath(path, this.#base);
-        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'DELETE', path }), headers, extractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
+        return _fetch(this.#merge(await this.#getDefs(), { ...(fetchParams || {}), data, method: 'DELETE', path }), headers, errorExtractor ?? this.#factoryErrorMessageExtractor, _dumpParams);
     }
     /**
      * Helper method to build the full URL from a path.

package/dist/mod.d.ts

@@ -21,6 +21,6 @@
  * }
  * ```
  */
-export { HttpApi, createHttpApi, type DataOptions, type GetOptions, type FetchParams, type ErrorMessageExtractor, type ResponseHeaders, type RequestData, } from "./api.js";
+export { HttpApi, createHttpApi, opts, type DataOptions, type GetOptions, type FetchParams, type ErrorMessageExtractor, type ResponseHeaders, type RequestData, } from "./api.js";
 export { HTTP_ERROR, createHttpError, getErrorMessage } from "./error.js";
 export { HTTP_STATUS } from "./status.js";

package/dist/mod.js

@@ -21,6 +21,6 @@
  * }
  * ```
  */
-export { HttpApi, createHttpApi, } from "./api.js";
+export { HttpApi, createHttpApi, opts, } from "./api.js";
 export { HTTP_ERROR, createHttpError, getErrorMessage } from "./error.js";
 export { HTTP_STATUS } from "./status.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@marianmeres/http-utils",
-	"version": "2.1.0",
+	"version": "2.3.0",
 	"type": "module",
 	"main": "dist/mod.js",
 	"types": "dist/mod.d.ts",