@fgrzl/fetch 1.4.0-alpha.2 → 1.4.0

package/dist/index.d.ts

@@ -1,9 +1,3 @@
-/**
- * @fileoverview Type definitions for the HTTP client.
- *
- * This file contains core TypeScript interfaces and types for FetchClient.
- * Designed for discoverability and type safety.
- */
 /**
  * Typed response wrapper with consistent shape.
  *
@@ -73,6 +67,20 @@ interface FetchClientOptions {
      * ```
      */
     baseUrl?: string;
+    /**
+     * Default timeout for requests in milliseconds.
+     *
+     * When set, requests will automatically be aborted after this duration.
+     * Individual requests can override this by providing their own timeout or signal.
+     * Set to 0 or undefined for no timeout.
+     *
+     * @example
+     * ```typescript
+     * const client = new FetchClient({ timeout: 5000 }); // 5 second timeout
+     * await client.get('/api/users'); // Will timeout after 5 seconds
+     * ```
+     */
+    timeout?: number;
 }
 
 /**
@@ -130,6 +138,7 @@ declare class FetchClient {
     private middlewares;
     private credentials;
     private baseUrl;
+    private defaultTimeout;
     constructor(config?: FetchClientOptions);
     use(middleware: FetchMiddleware): this;
     /**
@@ -152,12 +161,15 @@ declare class FetchClient {
      *
      * @example Chain with middleware:
      * ```typescript
-     * const client = useProductionStack(new FetchClient())
+     * const client = addProductionStack(new FetchClient())
      *   .setBaseUrl(process.env.API_BASE_URL);
      * ```
      */
     setBaseUrl(baseUrl?: string): this;
-    request<T = unknown>(url: string, init?: RequestInit): Promise<FetchResponse<T>>;
+    request<T = unknown>(url: string, init?: RequestInit, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
     private coreFetch;
     private parseResponse;
     private buildUrlWithParams;
@@ -178,6 +190,7 @@ declare class FetchClient {
      * @template T - Expected response data type (will be null for HEAD requests)
      * @param url - Request URL
      * @param params - Query parameters to append to URL
+     * @param options - Request options (signal, timeout)
      * @returns Promise resolving to typed response (data will always be null)
      *
      * @example Check if resource exists:
@@ -190,15 +203,17 @@ declare class FetchClient {
      * }
      * ```
      *
-     * @example Check with query parameters:
+     * @example With cancellation:
      * ```typescript
-     * const exists = await client.head('/api/users', { id: 123 });
-     * if (exists.status === 404) {
-     *   console.log('User not found');
-     * }
+     * const controller = new AbortController();
+     * const request = client.head('/api/users', { id: 123 }, { signal: controller.signal });
+     * controller.abort(); // Cancel the request
      * ```
      */
-    head<T = null>(url: string, params?: Record<string, string | number | boolean | undefined>): Promise<FetchResponse<T>>;
+    head<T = null>(url: string, params?: Record<string, string | number | boolean | undefined>, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
     /**
      * HEAD request that returns useful metadata about a resource.
      *
@@ -234,6 +249,7 @@ declare class FetchClient {
      * @template T - Expected response data type
      * @param url - Request URL
      * @param params - Query parameters to append to URL
+     * @param options - Request options (signal, timeout)
      * @returns Promise resolving to typed response
      *
      * @example
@@ -242,8 +258,16 @@ declare class FetchClient {
      * const filteredUsers = await client.get<User[]>('/api/users', { status: 'active', limit: 10 });
      * if (users.ok) console.log(users.data);
      * ```
+     *
+     * @example With timeout:
+     * ```typescript
+     * const users = await client.get<User[]>('/api/users', {}, { timeout: 5000 });
+     * ```
      */
-    get<T>(url: string, params?: Record<string, string | number | boolean | undefined>): Promise<FetchResponse<T>>;
+    get<T>(url: string, params?: Record<string, string | number | boolean | undefined>, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
     /**
      * POST request with automatic JSON serialization.
      *
@@ -251,14 +275,25 @@ declare class FetchClient {
      * @param url - Request URL
      * @param body - Request body (auto-serialized to JSON)
      * @param headers - Additional headers (Content-Type: application/json is default)
+     * @param options - Request options (signal, timeout)
      * @returns Promise resolving to typed response
      *
      * @example
      * ```typescript
      * const result = await client.post<User>('/api/users', { name: 'John' });
      * ```
+     *
+     * @example With cancellation:
+     * ```typescript
+     * const controller = new AbortController();
+     * const result = client.post('/api/users', { name: 'John' }, {}, { signal: controller.signal });
+     * controller.abort();
+     * ```
      */
-    post<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<FetchResponse<T>>;
+    post<T>(url: string, body?: unknown, headers?: Record<string, string>, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
     /**
      * PUT request with automatic JSON serialization.
      *
@@ -266,9 +301,13 @@ declare class FetchClient {
      * @param url - Request URL
      * @param body - Request body (auto-serialized to JSON)
      * @param headers - Additional headers (Content-Type: application/json is default)
+     * @param options - Request options (signal, timeout)
      * @returns Promise resolving to typed response
      */
-    put<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<FetchResponse<T>>;
+    put<T>(url: string, body?: unknown, headers?: Record<string, string>, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
     /**
      * PATCH request with automatic JSON serialization.
      *
@@ -276,15 +315,20 @@ declare class FetchClient {
      * @param url - Request URL
      * @param body - Request body (auto-serialized to JSON)
      * @param headers - Additional headers (Content-Type: application/json is default)
+     * @param options - Request options (signal, timeout)
      * @returns Promise resolving to typed response
      */
-    patch<T>(url: string, body?: unknown, headers?: Record<string, string>): Promise<FetchResponse<T>>;
+    patch<T>(url: string, body?: unknown, headers?: Record<string, string>, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
     /**
      * DELETE request with query parameter support.
      *
      * @template T - Expected response data type
      * @param url - Request URL
      * @param params - Query parameters to append to URL
+     * @param options - Request options (signal, timeout)
      * @returns Promise resolving to typed response
      *
      * @example
@@ -294,7 +338,10 @@ declare class FetchClient {
      * if (result.ok) console.log('Deleted successfully');
      * ```
      */
-    del<T>(url: string, params?: Record<string, string | number | boolean | undefined>): Promise<FetchResponse<T>>;
+    del<T>(url: string, params?: Record<string, string | number | boolean | undefined>, options?: {
+        signal?: AbortSignal;
+        timeout?: number;
+    }): Promise<FetchResponse<T>>;
 }
 
 /**
@@ -533,14 +580,14 @@ interface AuthenticationOptions {
  *
  * @example Basic usage:
  * ```typescript
- * const authClient = useAuthentication(client, {
+ * const authClient = addAuthentication(client, {
  *   tokenProvider: () => localStorage.getItem('token') || ''
  * });
  * ```
  *
  * @example Async token provider:
  * ```typescript
- * const authClient = useAuthentication(client, {
+ * const authClient = addAuthentication(client, {
  *   tokenProvider: async () => {
  *     const token = await getAuthToken();
  *     return token || '';
@@ -564,14 +611,14 @@ declare function createAuthenticationMiddleware(options: AuthenticationOptions):
  *
  * @example Basic token from localStorage:
  * ```typescript
- * const authClient = useAuthentication(client, {
+ * const authClient = addAuthentication(client, {
  *   tokenProvider: () => localStorage.getItem('auth-token') || ''
  * });
  * ```
  *
  * @example Async token with refresh:
  * ```typescript
- * const authClient = useAuthentication(client, {
+ * const authClient = addAuthentication(client, {
  *   tokenProvider: async () => {
  *     let token = localStorage.getItem('auth-token');
  *     if (!token || isExpired(token)) {
@@ -582,7 +629,7 @@ declare function createAuthenticationMiddleware(options: AuthenticationOptions):
  * });
  * ```
  */
-declare function useAuthentication(client: FetchClient, options: AuthenticationOptions): FetchClient;
+declare function addAuthentication(client: FetchClient, options: AuthenticationOptions): FetchClient;
 
 /**
  * @fileoverview Authorization middleware types and configuration.
@@ -698,13 +745,13 @@ interface AuthorizationOptions {
  *
  * @example Smart defaults (no configuration needed):
  * ```typescript
- * const authzClient = useAuthorization(client);
+ * const authzClient = addAuthorization(client);
  * // Redirects to '/login?return_url=current-page' on 401
  * ```
  *
  * @example Custom redirect configuration:
  * ```typescript
- * const authzClient = useAuthorization(client, {
+ * const authzClient = addAuthorization(client, {
  *   redirectConfig: {
  *     redirectPath: '/signin',
  *     returnUrlParam: 'redirect_to'
@@ -714,14 +761,14 @@ interface AuthorizationOptions {
  *
  * @example Manual handler (full control):
  * ```typescript
- * const authzClient = useAuthorization(client, {
+ * const authzClient = addAuthorization(client, {
  *   onUnauthorized: () => window.location.href = '/login'
  * });
  * ```
  *
  * @example Handle both 401 and 403:
  * ```typescript
- * const authzClient = useAuthorization(client, {
+ * const authzClient = addAuthorization(client, {
  *   onForbidden: () => showAccessDeniedMessage(),
  *   statusCodes: [401, 403]
  * });
@@ -743,20 +790,20 @@ declare function createAuthorizationMiddleware(options?: AuthorizationOptions):
  *
  * @example Smart defaults - no configuration needed:
  * ```typescript
- * const authzClient = useAuthorization(client);
+ * const authzClient = addAuthorization(client);
  * // Redirects to '/login?return_url=current-page' on 401
  * ```
  *
  * @example Custom redirect path:
  * ```typescript
- * const authzClient = useAuthorization(client, {
+ * const authzClient = addAuthorization(client, {
  *   redirectConfig: { redirectPath: '/signin', returnUrlParam: 'redirect_to' }
  * });
  * ```
  *
  * @example Manual handler (full control):
  * ```typescript
- * const authzClient = useAuthorization(client, {
+ * const authzClient = addAuthorization(client, {
  *   onUnauthorized: () => {
  *     localStorage.removeItem('auth-token');
  *     window.location.href = '/login';
@@ -766,13 +813,13 @@ declare function createAuthorizationMiddleware(options?: AuthorizationOptions):
  *
  * @example Handle multiple status codes:
  * ```typescript
- * const authzClient = useAuthorization(client, {
+ * const authzClient = addAuthorization(client, {
  *   onForbidden: () => showAccessDenied(),
  *   statusCodes: [401, 403]
  * });
  * ```
  */
-declare function useAuthorization(client: FetchClient, options?: AuthorizationOptions): FetchClient;
+declare function addAuthorization(client: FetchClient, options?: AuthorizationOptions): FetchClient;
 
 /**
  * @fileoverview Cache middleware types and configuration.
@@ -875,13 +922,13 @@ interface CacheOptions {
  *
  * @example Basic caching:
  * ```typescript
- * const cachedClient = useCache(client);
+ * const cachedClient = addCache(client);
  * // GET requests will be cached for 5 minutes
  * ```
  *
  * @example Custom TTL:
  * ```typescript
- * const cachedClient = useCache(client, {
+ * const cachedClient = addCache(client, {
  *   ttl: 10 * 60 * 1000 // 10 minutes
  * });
  * ```
@@ -902,7 +949,7 @@ declare function createCacheMiddleware(options?: CacheOptions): FetchMiddleware;
  *
  * @example Basic caching (5 minute TTL):
  * ```typescript
- * const cachedClient = useCache(client);
+ * const cachedClient = addCache(client);
  *
  * // First call hits the network
  * await cachedClient.get('/api/data');
@@ -913,7 +960,7 @@ declare function createCacheMiddleware(options?: CacheOptions): FetchMiddleware;
  *
  * @example Custom TTL and methods:
  * ```typescript
- * const cachedClient = useCache(client, {
+ * const cachedClient = addCache(client, {
  *   ttl: 10 * 60 * 1000, // 10 minutes
  *   methods: ['GET', 'HEAD']
  * });
@@ -921,13 +968,13 @@ declare function createCacheMiddleware(options?: CacheOptions): FetchMiddleware;
  *
  * @example Stale-while-revalidate:
  * ```typescript
- * const cachedClient = useCache(client, {
+ * const cachedClient = addCache(client, {
  *   staleWhileRevalidate: true
  * });
  * // Returns stale data immediately, updates cache in background
  * ```
  */
-declare function useCache(client: FetchClient, options?: CacheOptions): FetchClient;
+declare function addCache(client: FetchClient, options?: CacheOptions): FetchClient;
 
 /**
  * @fileoverview CSRF protection middleware types and configuration.
@@ -1005,7 +1052,7 @@ interface CSRFOptions {
  * @example Basic usage (automatic cookie-based CSRF):
  * ```typescript
  * const client = new FetchClient();
- * const protectedClient = useCSRF(client);
+ * const protectedClient = addCSRF(client);
  *
  * // CSRF token automatically added to POST requests
  * await protectedClient.post('/api/users', { name: 'John' });
@@ -1013,14 +1060,14 @@ interface CSRFOptions {
  *
  * @example Custom token provider:
  * ```typescript
- * const protectedClient = useCSRF(client, {
+ * const protectedClient = addCSRF(client, {
  *   tokenProvider: () => localStorage.getItem('csrf-token') || ''
  * });
  * ```
  *
  * @example Custom header and cookie names:
  * ```typescript
- * const protectedClient = useCSRF(client, {
+ * const protectedClient = addCSRF(client, {
  *   headerName: 'X-CSRF-Token',
  *   cookieName: 'csrf-token'
  * });
@@ -1028,7 +1075,7 @@ interface CSRFOptions {
  *
  * @example Skip patterns for external APIs:
  * ```typescript
- * const protectedClient = useCSRF(client, {
+ * const protectedClient = addCSRF(client, {
  *   skipPatterns: [
  *     /^https:\/\/api\.external\.com\//,  // Skip external API
  *     '/webhook/',                        // Skip webhook endpoints
@@ -1037,7 +1084,7 @@ interface CSRFOptions {
  * });
  * ```
  */
-declare function useCSRF(client: FetchClient, options?: CSRFOptions): FetchClient;
+declare function addCSRF(client: FetchClient, options?: CSRFOptions): FetchClient;
 
 /**
  * @fileoverview Logging middleware types and configuration.
@@ -1141,13 +1188,13 @@ interface LoggingOptions {
  *
  * @example Basic logging:
  * ```typescript
- * const loggedClient = useLogging(client);
+ * const loggedClient = addLogging(client);
  * // Logs all requests to console
  * ```
  *
  * @example Custom logger:
  * ```typescript
- * const loggedClient = useLogging(client, {
+ * const loggedClient = addLogging(client, {
  *   logger: winston.createLogger({...}),
  *   level: 'debug',
  *   includeRequestHeaders: true
@@ -1170,7 +1217,7 @@ declare function createLoggingMiddleware(options?: LoggingOptions): FetchMiddlew
  *
  * @example Basic logging to console:
  * ```typescript
- * const loggedClient = useLogging(client);
+ * const loggedClient = addLogging(client);
  *
  * // Logs: → GET /api/users
  * // Logs: ← GET /api/users → 200 (245ms)
@@ -1179,7 +1226,7 @@ declare function createLoggingMiddleware(options?: LoggingOptions): FetchMiddlew
  *
  * @example Custom log level and headers:
  * ```typescript
- * const loggedClient = useLogging(client, {
+ * const loggedClient = addLogging(client, {
  *   level: 'debug',
  *   includeRequestHeaders: true,
  *   includeResponseHeaders: true
@@ -1188,12 +1235,12 @@ declare function createLoggingMiddleware(options?: LoggingOptions): FetchMiddlew
  *
  * @example Skip health check endpoints:
  * ```typescript
- * const loggedClient = useLogging(client, {
+ * const loggedClient = addLogging(client, {
  *   skipPatterns: ['/health', '/metrics', '/ping']
  * });
  * ```
  */
-declare function useLogging(client: FetchClient, options?: LoggingOptions): FetchClient;
+declare function addLogging(client: FetchClient, options?: LoggingOptions): FetchClient;
 
 /**
  * @fileoverview Rate limiting middleware types and configuration.
@@ -1315,7 +1362,7 @@ declare function createRateLimitMiddleware(options?: RateLimitOptions): FetchMid
  * - Bulk operations that need throttling
  * - Pay-per-request API cost management
  */
-declare function useRateLimit(client: FetchClient, options?: RateLimitOptions): FetchClient;
+declare function addRateLimit(client: FetchClient, options?: RateLimitOptions): FetchClient;
 
 /**
  * @fileoverview Retry middleware types and configuration.
@@ -1415,7 +1462,7 @@ interface RetryOptions {
  */
 declare function createRetryMiddleware(options?: RetryOptions): FetchMiddleware;
 
-declare function useRetry(client: FetchClient, options?: RetryOptions): FetchClient;
+declare function addRetry(client: FetchClient, options?: RetryOptions): FetchClient;
 
 /**
  * @fileoverview Complete middleware collection for FetchClient - "pit of success" APIs.
@@ -1431,21 +1478,21 @@ declare function useRetry(client: FetchClient, options?: RetryOptions): FetchCli
  *
  * Each middleware follows the "pit of success" pattern with:
  * - Smart defaults for common scenarios
- * - Simple `use{Middleware}()` convenience functions
+ * - Simple `add{Middleware}()` convenience functions
  * - Advanced `create{Middleware}Middleware()` for custom scenarios
  * - Comprehensive TypeScript support
  *
  * @example Quick setup with multiple middleware:
  * ```typescript
  * import { FetchClient } from '@fgrzl/fetch';
- * import { useAuthentication, useRetry, useLogging } from '@fgrzl/fetch/middleware';
+ * import { addAuthentication, addRetry, addLogging } from '@fgrzl/fetch/middleware';
  *
  * const client = new FetchClient();
- * const enhancedClient = useAuthentication(client, {
+ * const enhancedClient = addAuthentication(client, {
  *   tokenProvider: () => localStorage.getItem('auth-token') || ''
  * })
- * .pipe(useRetry, { retries: 3 })
- * .pipe(useLogging);
+ * .pipe(addRetry, { retries: 3 })
+ * .pipe(addLogging);
  * ```
  */
 
@@ -1459,19 +1506,19 @@ declare function useRetry(client: FetchClient, options?: RetryOptions): FetchCli
  *
  * @example
  * ```typescript
- * const apiClient = useProductionStack(new FetchClient(), {
+ * const apiClient = addProductionStack(new FetchClient(), {
  *   auth: { tokenProvider: () => getAuthToken() },
  *   cache: { ttl: 5 * 60 * 1000 }, // 5 minutes
  *   logging: { level: 'info' }
  * });
  * ```
  */
-declare function useProductionStack(client: FetchClient, config?: {
-    auth?: Parameters<typeof useAuthentication>[1];
-    retry?: Parameters<typeof useRetry>[1];
-    cache?: Parameters<typeof useCache>[1];
-    logging?: Parameters<typeof useLogging>[1];
-    rateLimit?: Parameters<typeof useRateLimit>[1];
+declare function addProductionStack(client: FetchClient, config?: {
+    auth?: Parameters<typeof addAuthentication>[1];
+    retry?: Parameters<typeof addRetry>[1];
+    cache?: Parameters<typeof addCache>[1];
+    logging?: Parameters<typeof addLogging>[1];
+    rateLimit?: Parameters<typeof addRateLimit>[1];
 }): FetchClient;
 /**
  * Development-friendly middleware stack with comprehensive logging and retries.
@@ -1483,13 +1530,13 @@ declare function useProductionStack(client: FetchClient, config?: {
  *
  * @example
  * ```typescript
- * const devClient = useDevelopmentStack(new FetchClient(), {
+ * const devClient = addDevelopmentStack(new FetchClient(), {
  *   auth: { tokenProvider: () => 'dev-token' }
  * });
  * ```
  */
-declare function useDevelopmentStack(client: FetchClient, config?: {
-    auth?: Parameters<typeof useAuthentication>[1];
+declare function addDevelopmentStack(client: FetchClient, config?: {
+    auth?: Parameters<typeof addAuthentication>[1];
 }): FetchClient;
 /**
  * Basic middleware stack with just authentication and retry.
@@ -1501,13 +1548,13 @@ declare function useDevelopmentStack(client: FetchClient, config?: {
  *
  * @example
  * ```typescript
- * const basicClient = useBasicStack(new FetchClient(), {
+ * const basicClient = addBasicStack(new FetchClient(), {
  *   auth: { tokenProvider: () => getToken() }
  * });
  * ```
  */
-declare function useBasicStack(client: FetchClient, config: {
-    auth: Parameters<typeof useAuthentication>[1];
+declare function addBasicStack(client: FetchClient, config: {
+    auth: Parameters<typeof addAuthentication>[1];
 }): FetchClient;
 
 /**
@@ -1559,18 +1606,18 @@ declare function useBasicStack(client: FetchClient, config: {
  * @example Configure authentication:
  * ```typescript
  * import api from '@fgrzl/fetch';
- * import { useAuthentication } from '@fgrzl/fetch/middleware';
+ * import { addAuthentication } from '@fgrzl/fetch/middleware';
  *
- * const authClient = useAuthentication(api, {
+ * const authClient = addAuthentication(api, {
  *   tokenProvider: () => localStorage.getItem('auth-token') || ''
  * });
  * ```
  *
  * @example For token-only auth (no cookies):
  * ```typescript
- * import { FetchClient, useAuthentication } from '@fgrzl/fetch';
+ * import { FetchClient, addAuthentication } from '@fgrzl/fetch';
  *
- * const tokenClient = useAuthentication(new FetchClient({
+ * const tokenClient = addAuthentication(new FetchClient({
  *   credentials: 'omit' // Don't send cookies
  * }), {
  *   tokenProvider: () => getJWTToken()
@@ -1579,10 +1626,10 @@ declare function useBasicStack(client: FetchClient, config: {
  *
  * @example Production-ready API client with base URL:
  * ```typescript
- * import { FetchClient, useProductionStack } from '@fgrzl/fetch';
+ * import { FetchClient, addProductionStack } from '@fgrzl/fetch';
  *
  * // One-liner production setup with base URL
- * const apiClient = useProductionStack(new FetchClient(), {
+ * const apiClient = addProductionStack(new FetchClient(), {
  *   auth: { tokenProvider: () => getAuthToken() },
  *   retry: { maxRetries: 3 },
  *   logging: { level: 'info' }
@@ -1594,4 +1641,4 @@ declare function useBasicStack(client: FetchClient, config: {
  */
 declare const api: FetchClient;
 
-export { type AuthTokenProvider, type AuthenticationOptions, type AuthorizationOptions, type CacheEntry, type CacheKeyGenerator, type CacheOptions, type CacheStorage, FetchClient, type FetchClientOptions, FetchError, type FetchResponse, HttpError, type FetchMiddleware as InterceptMiddleware, type LogLevel, type Logger, type LoggingOptions, NetworkError, type QueryParams, type QueryValue, type RateLimitAlgorithm, type RateLimitOptions, type RetryOptions, type UnauthorizedHandler, appendQueryParams, buildQueryParams, createAuthenticationMiddleware, createAuthorizationMiddleware, createCacheMiddleware, createLoggingMiddleware, createRateLimitMiddleware, createRetryMiddleware, api as default, useAuthentication, useAuthorization, useBasicStack, useCSRF, useCache, useDevelopmentStack, useLogging, useProductionStack, useRateLimit, useRetry };
+export { type AuthTokenProvider, type AuthenticationOptions, type AuthorizationOptions, type CacheEntry, type CacheKeyGenerator, type CacheOptions, type CacheStorage, FetchClient, type FetchClientOptions, FetchError, type FetchResponse, HttpError, type FetchMiddleware as InterceptMiddleware, type LogLevel, type Logger, type LoggingOptions, NetworkError, type QueryParams, type QueryValue, type RateLimitAlgorithm, type RateLimitOptions, type RetryOptions, type UnauthorizedHandler, addAuthentication, addAuthorization, addBasicStack, addCSRF, addCache, addDevelopmentStack, addLogging, addProductionStack, addRateLimit, addRetry, appendQueryParams, buildQueryParams, createAuthenticationMiddleware, createAuthorizationMiddleware, createCacheMiddleware, createLoggingMiddleware, createRateLimitMiddleware, createRetryMiddleware, api as default };