@gnwebsoft/ui 4.0.3 → 4.0.5

package/dist/core/api/Interceptors/InterceptorManager.d.ts

@@ -0,0 +1,236 @@
+import type { ApiError } from '../types/ApiError';
+import type { ErrorInterceptor } from '../types/ErrorInterceptor';
+import type { RequestConfig } from '../types/RequestConfig';
+import type { RequestInterceptor } from '../types/RequestInterceptor';
+import type { ResponseInterceptor } from '../types/ResponseInterceptor';
+import type { ApiResponse } from '@/types';
+/**
+ * Manages the registration and execution of request/response/error interceptors.
+ *
+ * This internal class implements the interceptor pattern, allowing middleware-style
+ * functions to be registered and executed at different points in the request lifecycle:
+ * - **Request Interceptors**: Modify requests before they are sent
+ * - **Response Interceptors**: Transform responses before they are returned
+ * - **Error Interceptors**: Handle or transform errors before they are thrown
+ *
+ * Interceptors are executed sequentially in the order they were registered,
+ * forming a processing pipeline. Each interceptor can:
+ * - Inspect the data passing through
+ * - Transform or enhance the data
+ * - Short-circuit the pipeline (for errors)
+ * - Perform side effects (logging, monitoring, etc.)
+ *
+ * Key Features:
+ * - **Sequential Execution**: Interceptors run in registration order
+ * - **Unregistration Support**: Returns cleanup function for each interceptor
+ * - **Type Safety**: Fully typed interceptor functions with generics
+ * - **Error Handling**: Graceful handling of interceptor failures
+ *
+ * @internal This class is not exported from the public API
+ *
+ * @example
+ * Common interceptor patterns:
+ * ```typescript
+ * const manager = new InterceptorManager();
+ *
+ * // Request logging
+ * manager.addRequestInterceptor(async (config) => {
+ *   console.log('Request:', config.method, config.url);
+ *   return config;
+ * });
+ *
+ * // Response transformation
+ * manager.addResponseInterceptor(async (response) => {
+ *   if (response.apiData) {
+ *     response.apiData = camelCaseKeys(response.apiData);
+ *   }
+ *   return response;
+ * });
+ *
+ * // Error monitoring
+ * manager.addErrorInterceptor(async (error) => {
+ *   if (error.status >= 500) {
+ *     await logToMonitoring(error);
+ *   }
+ *   throw error; // Re-throw to maintain error flow
+ * });
+ * ```
+ */
+export declare class InterceptorManager {
+    /**
+     * Array of registered request interceptors
+     * @private
+     */
+    private readonly requestInterceptors;
+    /**
+     * Array of registered response interceptors
+     * @private
+     */
+    private readonly responseInterceptors;
+    /**
+     * Array of registered error interceptors
+     * @private
+     */
+    private readonly errorInterceptors;
+    /**
+     * Registers a request interceptor to modify requests before they are sent.
+     *
+     * Request interceptors can:
+     * - Add or modify headers
+     * - Transform request bodies
+     * - Add query parameters
+     * - Implement request signing
+     * - Log outgoing requests
+     *
+     * @param interceptor - Async function that receives and returns RequestConfig
+     * @returns Cleanup function to unregister this interceptor
+     *
+     * @example
+     * ```typescript
+     * // Add authentication header
+     * const unregister = manager.addRequestInterceptor(async (config) => {
+     *   const token = await getAuthToken();
+     *   config.headers = config.headers || new Headers();
+     *   config.headers.set('Authorization', `Bearer ${token}`);
+     *   return config;
+     * });
+     *
+     * // Later, remove the interceptor
+     * unregister();
+     * ```
+     */
+    addRequestInterceptor(interceptor: RequestInterceptor): () => void;
+    /**
+     * Registers a response interceptor to transform responses before they are returned.
+     *
+     * Response interceptors can:
+     * - Transform response data format
+     * - Extract nested data structures
+     * - Add computed properties
+     * - Cache responses
+     * - Log successful responses
+     *
+     * @param interceptor - Async function that receives and returns ApiResponse
+     * @returns Cleanup function to unregister this interceptor
+     *
+     * @example
+     * ```typescript
+     * // Extract data from envelope
+     * manager.addResponseInterceptor(async (response) => {
+     *   if (response.apiData?.result) {
+     *     response.apiData = response.apiData.result;
+     *   }
+     *   return response;
+     * });
+     *
+     * // Add timestamps
+     * manager.addResponseInterceptor(async (response) => {
+     *   return {
+     *     ...response,
+     *     receivedAt: new Date().toISOString()
+     *   };
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): () => void;
+    /**
+     * Registers an error interceptor to handle or transform errors before they are thrown.
+     *
+     * Error interceptors can:
+     * - Log errors to monitoring services
+     * - Transform error formats
+     * - Implement retry logic
+     * - Show user notifications
+     * - Extract validation errors
+     *
+     * **Note:** Error interceptors should re-throw the error (or a transformed version)
+     * to maintain the error flow. The final error is always thrown.
+     *
+     * @param interceptor - Async function that receives and returns (or throws) ApiError
+     * @returns Cleanup function to unregister this interceptor
+     *
+     * @example
+     * ```typescript
+     * // Log to monitoring service
+     * manager.addErrorInterceptor(async (error) => {
+     *   if (error.status >= 500) {
+     *     await Sentry.captureException(error, {
+     *       extra: { traceId: error.traceId }
+     *     });
+     *   }
+     *   throw error; // Re-throw to continue error flow
+     * });
+     *
+     * // Transform error messages
+     * manager.addErrorInterceptor(async (error) => {
+     *   if (error.status === 404) {
+     *     error.title = 'Resource not found';
+     *   }
+     *   throw error;
+     * });
+     * ```
+     */
+    addErrorInterceptor(interceptor: ErrorInterceptor): () => void;
+    /**
+     * Applies all registered request interceptors in sequential order.
+     *
+     * Each interceptor receives the config modified by the previous interceptor,
+     * forming a processing pipeline. If any interceptor throws an error,
+     * the pipeline stops and the error propagates.
+     *
+     * @param config - The initial request configuration
+     * @returns The modified request configuration after all interceptors
+     *
+     * @example
+     * ```typescript
+     * const config = { method: 'GET', url: '/users' };
+     * const finalConfig = await manager.applyRequestInterceptors(config);
+     * // finalConfig has been processed by all registered interceptors
+     * ```
+     */
+    applyRequestInterceptors(config: RequestConfig): Promise<RequestConfig>;
+    /**
+     * Applies all registered response interceptors in sequential order.
+     *
+     * Each interceptor receives the response modified by the previous interceptor,
+     * forming a processing pipeline. If any interceptor throws an error,
+     * the pipeline stops and the error propagates.
+     *
+     * @template T - The type of the response data
+     * @param response - The initial API response
+     * @returns The modified response after all interceptors
+     *
+     * @example
+     * ```typescript
+     * const response = { data: { id: 1, name: 'John' } };
+     * const finalResponse = await manager.applyResponseInterceptors(response);
+     * // finalResponse has been processed by all registered interceptors
+     * ```
+     */
+    applyResponseInterceptors<T>(response: ApiResponse<T>): Promise<ApiResponse<T>>;
+    /**
+     * Applies all registered error interceptors in sequential order and re-throws.
+     *
+     * Each interceptor receives the error (potentially modified by previous interceptors).
+     * Interceptors can transform the error before re-throwing it. The final error
+     * is always thrown to maintain error flow.
+     *
+     * If an interceptor itself throws an error, that becomes the new error to process
+     * by subsequent interceptors.
+     *
+     * @param error - The initial API error
+     * @returns Never returns (always throws)
+     * @throws The final error after all interceptors have processed it
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await manager.applyErrorInterceptors(error);
+     * } catch (finalError) {
+     *   // finalError has been processed by all registered error interceptors
+     * }
+     * ```
+     */
+    applyErrorInterceptors(error: ApiError): Promise<never>;
+}
+//# sourceMappingURL=InterceptorManager.d.ts.map

package/dist/core/api/Interceptors/InterceptorManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InterceptorManager.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Interceptors/InterceptorManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA4B;IAEhE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA6B;IAElE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA0B;IAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,qBAAqB,CAAC,WAAW,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAUlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,sBAAsB,CAAC,WAAW,EAAE,mBAAmB,GAAG,MAAM,IAAI;IAUpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAU9D;;;;;;;;;;;;;;;;OAgBG;IACG,wBAAwB,CAC5B,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,aAAa,CAAC;IAUzB;;;;;;;;;;;;;;;;;OAiBG;IACG,yBAAyB,CAAC,CAAC,EAC/B,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,GACvB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAU1B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,sBAAsB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC;CAa9D"}

package/dist/core/api/Models/FilterModel.d.ts

@@ -0,0 +1,22 @@
+import type { GridSortModel } from '@mui/x-data-grid';
+/**
+ * Generic filter model for list requests with pagination and sorting
+ * @template TFilterModel - The specific filter criteria type
+ */
+export interface PostModel<TFilterModel = Record<string, unknown>> {
+    filterModel?: TFilterModel;
+    pageOffset: number;
+    pageSize: number;
+    sortField: string | null;
+    sortOrder: 'asc' | 'desc' | null | undefined;
+    sortModel?: GridSortModel;
+}
+/**
+ * Standardized list response structure for paginated data
+ * @template TListModel - The type of individual list items
+ */
+export interface ListResponse<TListModel> {
+    Data: TListModel[];
+    Total: number;
+}
+//# sourceMappingURL=FilterModel.d.ts.map

package/dist/core/api/Models/FilterModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterModel.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Models/FilterModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/D,WAAW,CAAC,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,UAAU;IACtC,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/core/api/Models/QueryParams.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Primitive types that can be used as query parameters
+ */
+export type QueryParamValue = string | number | boolean | null | undefined;
+/**
+ * Record type for URL query parameters
+ */
+export type QueryParams = Record<string, QueryParamValue | QueryParamValue[]>;
+/**
+ * Response data types supported by the API client
+ */
+export type ResponseData = Record<string, unknown> | string | Blob;
+//# sourceMappingURL=QueryParams.d.ts.map

package/dist/core/api/Models/QueryParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryParams.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Models/QueryParams.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,EAAE,CAAC,CAAC;AAE9E;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC"}

package/dist/core/api/Models/index.d.ts

@@ -0,0 +1,3 @@
+export type { PostModel, ListResponse } from './FilterModel';
+export type { QueryParamValue, QueryParams, ResponseData } from './QueryParams';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/api/Models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Models/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7D,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/core/api/RequestManager.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Manages active HTTP requests with support for cancellation and correlation tracking.
+ *
+ * This internal class maintains a registry of in-flight requests, allowing them to be
+ * cancelled individually or in bulk. Each request is tracked by a unique key and
+ * associated with a correlation ID for distributed tracing.
+ *
+ * Key Features:
+ * - **Request Deduplication**: Automatically cancels duplicate requests with the same key
+ * - **Correlation Tracking**: Maps request keys to correlation IDs for tracing
+ * - **Bulk Cancellation**: Cancel all pending requests at once (useful for cleanup)
+ * - **Memory Management**: Automatically cleans up tracking data when requests complete
+ *
+ * @internal This class is not exported from the public API
+ *
+ * @example
+ * ```typescript
+ * const manager = new RequestManager();
+ * const controller = new AbortController();
+ *
+ * // Track a request
+ * manager.add('GET_/users/123', controller, 'api-abc123');
+ *
+ * // Cancel specific request
+ * manager.cancel('GET_/users/123');
+ *
+ * // Or cancel all requests
+ * manager.cancelAll();
+ * ```
+ */
+export declare class RequestManager {
+    /**
+     * Map of active request keys to their abort controllers
+     * @private
+     */
+    private activeRequests;
+    /**
+     * Map of request keys to their correlation IDs for tracing
+     * @private
+     */
+    private correlationMap;
+    /**
+     * Registers a new request for tracking and cancellation management.
+     *
+     * If a request with the same key already exists, it will be automatically
+     * cancelled before the new one is registered (request deduplication).
+     *
+     * @param key - Unique identifier for the request (typically method + URL + timestamp)
+     * @param controller - AbortController for cancelling the request
+     * @param correlationId - Correlation ID for distributed tracing
+     *
+     * @example
+     * ```typescript
+     * const controller = new AbortController();
+     * manager.add('GET_/api/users_1699999999', controller, 'api-abc123');
+     * ```
+     */
+    add(key: string, controller: AbortController, correlationId: string): void;
+    /**
+     * Removes a request from tracking without cancelling it.
+     *
+     * This is typically called when a request completes successfully or fails.
+     * Use {@link cancel} instead if you need to abort the request.
+     *
+     * @param key - Unique identifier for the request to remove
+     *
+     * @example
+     * ```typescript
+     * // Called automatically after request completes
+     * manager.remove('GET_/api/users_1699999999');
+     * ```
+     */
+    remove(key: string): void;
+    /**
+     * Cancels a specific request and removes it from tracking.
+     *
+     * If the request doesn't exist or was already cancelled, this operation is a no-op.
+     * The associated AbortController's signal will be triggered, causing any active
+     * fetch operations to abort.
+     *
+     * @param key - Unique identifier for the request to cancel
+     *
+     * @example
+     * ```typescript
+     * // User navigates away, cancel the pending request
+     * manager.cancel('GET_/api/users_1699999999');
+     * ```
+     */
+    cancel(key: string): void;
+    /**
+     * Cancels all active requests and clears all tracking data.
+     *
+     * This is useful for cleanup scenarios such as:
+     * - User logout
+     * - Component unmount
+     * - Navigation to a different part of the application
+     * - Error recovery that requires a clean slate
+     *
+     * @example
+     * ```typescript
+     * // Cancel all pending requests on logout
+     * function handleLogout() {
+     *   apiClient.cancelAllRequests();
+     *   // ... rest of logout logic
+     * }
+     * ```
+     */
+    cancelAll(): void;
+    /**
+     * Checks if a request with the given key is currently being tracked.
+     *
+     * @param key - Unique identifier for the request
+     * @returns `true` if the request is active, `false` otherwise
+     *
+     * @example
+     * ```typescript
+     * if (manager.has('GET_/api/users_1699999999')) {
+     *   console.log('Request is still pending');
+     * }
+     * ```
+     */
+    has(key: string): boolean;
+    /**
+     * Retrieves the correlation ID for a given request key.
+     *
+     * Correlation IDs are used for distributed tracing and request tracking
+     * across services and logs.
+     *
+     * @param key - Unique identifier for the request
+     * @returns The correlation ID if found, `undefined` otherwise
+     *
+     * @example
+     * ```typescript
+     * const correlationId = manager.getCorrelationId('GET_/api/users_1699999999');
+     * if (correlationId) {
+     *   console.log('Trace request with ID:', correlationId);
+     * }
+     * ```
+     */
+    getCorrelationId(key: string): string | undefined;
+}
+//# sourceMappingURL=RequestManager.d.ts.map

package/dist/core/api/RequestManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestManager.d.ts","sourceRoot":"","sources":["../../../src/core/api/RequestManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,cAAc;IACzB;;;OAGG;IACH,OAAO,CAAC,cAAc,CAA2C;IAEjE;;;OAGG;IACH,OAAO,CAAC,cAAc,CAAkC;IAExD;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAO1E;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKzB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAUzB;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,IAAI,IAAI;IAMjB;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAGlD"}

package/dist/core/api/Retry/RetryHandler.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Implements automatic retry logic with exponential backoff for failed HTTP requests.
+ *
+ * This internal class handles transient failures by automatically retrying requests
+ * with progressively increasing delays between attempts. The exponential backoff
+ * strategy helps prevent overwhelming a struggling server while giving temporary
+ * issues time to resolve.
+ *
+ * Key Features:
+ * - **Exponential Backoff**: Doubles delay between retries (e.g., 1s, 2s, 4s, 8s)
+ * - **Smart Error Detection**: Skips retry for non-retryable errors (validation, aborts)
+ * - **Abort Support**: Respects cancellation signals during retry delays
+ * - **Type Safety**: Fully generic implementation preserving return types
+ *
+ * Retry Strategy:
+ * - **Retryable**: Network errors, 5xx server errors, timeouts
+ * - **Non-Retryable**: Validation errors (400), AbortErrors, cancelled requests
+ *
+ * @internal This class is not exported from the public API
+ *
+ * @example
+ * Retry configuration in ApiClient:
+ * ```typescript
+ * const client = new ApiClient('https://api.example.com');
+ *
+ * // Retry up to 3 times with 1s initial delay
+ * const { apiData } = await client.get('/users', {
+ *   retries: 3,
+ *   retryDelay: 1000  // 1s, 2s, 4s
+ * });
+ * ```
+ */
+export declare class RetryHandler {
+    /**
+     * Retries a failed request with exponential backoff strategy.
+     *
+     * The retry logic works as follows:
+     * 1. Attempts the request immediately
+     * 2. On failure, checks if the error is retryable
+     * 3. If retryable and retries remain, waits for the current delay
+     * 4. Doubles the delay for the next attempt
+     * 5. Repeats until success or retries exhausted
+     *
+     * **Non-Retryable Errors:**
+     * - Validation errors (400) - Client sent bad data
+     * - AbortErrors - Request was explicitly cancelled
+     * - Requests with aborted signals
+     *
+     * **Abort Handling:**
+     * If the signal is aborted during a retry delay, the retry is immediately
+     * cancelled and an AbortError is thrown.
+     *
+     * @template T - The return type of the function being retried
+     * @param fn - Async function to retry on failure
+     * @param retries - Number of retry attempts remaining (decrements each retry)
+     * @param delay - Current delay in milliseconds before next retry
+     * @param signal - Optional AbortSignal to cancel retries
+     * @returns Promise resolving to the function's result on success
+     * @throws The last error encountered if all retries are exhausted
+     * @throws AbortError if the signal is aborted during execution or delay
+     *
+     * @example
+     * Basic retry usage:
+     * ```typescript
+     * const handler = new RetryHandler();
+     * const fetchUser = () => fetch('/api/users/123').then(r => r.json());
+     *
+     * try {
+     *   const user = await handler.retryRequest(
+     *     fetchUser,
+     *     3,      // 3 retries
+     *     1000    // Start with 1s delay
+     *   );
+     *   console.log('User:', user);
+     * } catch (error) {
+     *   console.error('Failed after all retries:', error);
+     * }
+     * ```
+     *
+     * @example
+     * With cancellation support:
+     * ```typescript
+     * const controller = new AbortController();
+     * const signal = controller.signal;
+     *
+     * // Cancel after 5 seconds
+     * setTimeout(() => controller.abort(), 5000);
+     *
+     * try {
+     *   await handler.retryRequest(fetchUser, 5, 1000, signal);
+     * } catch (error) {
+     *   if (error.name === 'AbortError') {
+     *     console.log('Retry cancelled');
+     *   }
+     * }
+     * ```
+     */
+    retryRequest<T>(fn: () => Promise<T>, retries: number, delay: number, signal?: AbortSignal): Promise<T>;
+}
+//# sourceMappingURL=RetryHandler.d.ts.map

package/dist/core/api/Retry/RetryHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryHandler.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Retry/RetryHandler.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACG,YAAY,CAAC,CAAC,EAClB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC;CA0Cd"}