@gnwebsoft/ui 4.0.3 → 4.0.5

package/dist/chunk-Y3QTSDLJ.cjs

@@ -137,4 +137,4 @@ function useEnhancedTransform(options) {
 
 
 exports.useTransform = useTransform; exports.transformFactories = transformFactories; exports.useEnhancedTransform = useEnhancedTransform;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,329 @@
+import type { ListResponse, PostModel, ResponseData } from './Models';
+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';
+/**
+ * Enterprise-grade API client with advanced features for production applications.
+ *
+ * This client provides a robust, type-safe abstraction over the Fetch API with:
+ * - Comprehensive request/response/error interceptor system
+ * - Automatic retry logic with exponential backoff
+ * - Request correlation ID tracking for distributed tracing
+ * - Token-based authentication with automatic header injection
+ * - Request cancellation and timeout management
+ * - Type-safe error handling with structured error responses
+ * - React Query integration support
+ *
+ * Architecture Principles:
+ * - **Type Safety**: Full TypeScript inference with no `any` types
+ * - **Extensibility**: Interceptor pattern allows for flexible middleware
+ * - **Observability**: Built-in correlation IDs for request tracing
+ * - **Resilience**: Automatic retries, timeouts, and graceful error handling
+ * - **Performance**: Request deduplication and cancellation support
+ * - **Modularity**: Organized into focused, single-responsibility modules
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const client = new ApiClient('https://api.example.com', 30000);
+ * client.setAuthToken('your-jwt-token');
+ *
+ * // Type-safe GET request
+ * const { apiData, error } = await client.get<User>('/users/123');
+ * if (error) {
+ *   console.error('Failed to fetch user:', error);
+ * } else {
+ *   console.log('User data:', data);
+ * }
+ * ```
+ *
+ * @example
+ * With React Query:
+ * ```typescript
+ * const queryClient = new QueryClient();
+ * const apiClient = new ApiClient(process.env.API_BASE_URL);
+ *
+ * // Add logging interceptor
+ * apiClient.addResponseInterceptor(async (response) => {
+ *   console.log('Response received:', response);
+ *   return response;
+ * });
+ *
+ * // Use in queries
+ * const { apiData } = useQuery({
+ *   queryKey: ['users', userId],
+ *   queryFn: () => apiClient.get<User>(`/users/${userId}`)
+ * });
+ * ```
+ *
+ * @example
+ * Advanced error handling:
+ * ```typescript
+ * // Option 1: Errors thrown (default)
+ * try {
+ *   const { apiData } = await client.get<User>('/users/123');
+ *   console.log(data);
+ * } catch (error) {
+ *   if (error.status === 404) {
+ *     console.log('User not found');
+ *   }
+ * }
+ *
+ * // Option 2: Errors returned in response
+ * const { apiData, error } = await client.get<User>('/users/123', {
+ *   throwErrors: false
+ * });
+ * if (error) {
+ *   console.error('Request failed:', error);
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class ApiClient {
+    private readonly baseURL;
+    private readonly defaultTimeout;
+    private readonly interceptorManager;
+    private readonly signalManager;
+    private readonly errorNormalizer;
+    private readonly responseParser;
+    private readonly urlBuilder;
+    private readonly retryHandler;
+    private readonly requestManager;
+    private authToken;
+    private correlationIdPrefix;
+    private includeCorrelationId;
+    /**
+     * Creates a new API client instance
+     * @param baseURL - Base URL for all API requests (default: empty string for relative URLs)
+     * @param defaultTimeout - Default request timeout in milliseconds (default: 30000)
+     */
+    constructor(baseURL?: string, defaultTimeout?: number);
+    /**
+     * Sets the prefix for auto-generated correlation IDs
+     * @param prefix - The prefix to use for correlation IDs (e.g., 'api', 'web', 'mobile')
+     */
+    setCorrelationIdPrefix(prefix: string): void;
+    /**
+     * Enables or disables automatic correlation ID generation
+     * @param include - Whether to include correlation IDs in requests
+     */
+    setIncludeCorrelationId(include: boolean): void;
+    /**
+     * Registers a request interceptor to modify requests before they're sent
+     * @param interceptor - Function to intercept and potentially modify request config
+     * @returns Function to unregister this interceptor
+     *
+     * @example
+     * ```typescript
+     * const unregister = client.addRequestInterceptor(async (config) => {
+     *   config.headers = config.headers || new Headers();
+     *   config.headers.set('X-Client-Version', '1.0.0');
+     *   return config;
+     * });
+     *
+     * // Later, to remove the interceptor:
+     * unregister();
+     * ```
+     */
+    addRequestInterceptor(interceptor: RequestInterceptor): () => void;
+    /**
+     * Registers a response interceptor to modify responses before they're returned
+     * @param interceptor - Function to intercept and potentially modify responses
+     * @returns Function to unregister this interceptor
+     *
+     * @example
+     * ```typescript
+     * client.addResponseInterceptor(async (response) => {
+     *   // Transform data format
+     *   if (response.apiData) {
+     *     response.apiData = camelCaseKeys(response.apiData);
+     *   }
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseInterceptor(interceptor: ResponseInterceptor): () => void;
+    /**
+     * Registers an error interceptor to handle or transform errors
+     * @param interceptor - Function to intercept and potentially modify errors
+     * @returns Function to unregister this interceptor
+     *
+     * @example
+     * ```typescript
+     * client.addErrorInterceptor(async (error) => {
+     *   // Log errors to monitoring service
+     *   if (error.status >= 500) {
+     *     await monitoringService.logError(error);
+     *   }
+     *   return error; // Re-throw the error
+     * });
+     * ```
+     */
+    addErrorInterceptor(interceptor: ErrorInterceptor): () => void;
+    /**
+     * Sets the authentication token for subsequent requests
+     * @param token - JWT token or null to clear authentication
+     *
+     * @example
+     * ```typescript
+     * // Set token after login
+     * client.setAuthToken(loginResponse.accessToken);
+     *
+     * // Clear token on logout
+     * client.setAuthToken(null);
+     * ```
+     */
+    setAuthToken(token: string | null): void;
+    /**
+     * Retrieves the current authentication token
+     * @returns The current auth token or null if not set
+     */
+    getAuthToken(): string | null;
+    /**
+     * Cancels a specific request by its key
+     * @param key - The unique key identifying the request to cancel
+     */
+    cancelRequest(key: string): void;
+    /**
+     * Cancels all pending requests
+     * Useful for cleanup on navigation or component unmount
+     */
+    cancelAllRequests(): void;
+    /**
+     * Core request method that handles all HTTP operations
+     * @template T - The expected response data type
+     * @param endpoint - API endpoint relative to baseURL
+     * @param config - Request configuration options
+     * @returns Promise resolving to ApiResponse with data or error
+     *
+     * @example
+     * ```typescript
+     * const response = await client.request<User>('/users/123', {
+     *   method: 'GET',
+     *   timeout: 5000,
+     *   throwErrors: false
+     * });
+     * ```
+     */
+    request<T = ResponseData>(endpoint: string, config?: RequestConfig): Promise<ApiResponse<T, ApiError>>;
+    /**
+     * Performs a GET request
+     * @template T - The expected response data type
+     * @param endpoint - API endpoint
+     * @param config - Optional request configuration
+     * @returns Promise resolving to ApiResponse
+     *
+     * @example
+     * ```typescript
+     * const { apiData, error } = await client.get<User[]>('/users', {
+     *   params: { active: true },
+     *   timeout: 5000
+     * });
+     * ```
+     */
+    get<T = ResponseData>(endpoint: string, config?: RequestConfig): Promise<ApiResponse<T, ApiError>>;
+    /**
+     * Performs a POST request
+     * @template T - The expected response data type
+     * @template TData - The request body data type
+     * @param endpoint - API endpoint
+     * @param data - Request body data
+     * @param config - Optional request configuration
+     * @returns Promise resolving to ApiResponse
+     *
+     * @example
+     * ```typescript
+     * const { apiData, error } = await client.post<User, CreateUserDto>('/users', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com'
+     * });
+     * ```
+     */
+    post<T = ResponseData, TData extends BodyInit | Record<string, unknown> | null = Record<string, unknown>>(endpoint: string, data?: TData, config?: RequestConfig): Promise<ApiResponse<T, ApiError>>;
+    /**
+     * Performs a PUT request
+     * @template T - The expected response data type
+     * @template TData - The request body data type
+     * @param endpoint - API endpoint
+     * @param data - Request body data
+     * @param config - Optional request configuration
+     * @returns Promise resolving to ApiResponse
+     *
+     * @example
+     * ```typescript
+     * const { apiData, error } = await client.put<User, UpdateUserDto>(
+     *   '/users/123',
+     *   { name: 'Jane Doe' }
+     * );
+     * ```
+     */
+    put<T = ResponseData, TData extends BodyInit | Record<string, unknown> | null = Record<string, unknown>>(endpoint: string, data?: TData, config?: RequestConfig): Promise<ApiResponse<T, ApiError>>;
+    /**
+     * Performs a PATCH request
+     * @template T - The expected response data type
+     * @template TData - The request body data type
+     * @param endpoint - API endpoint
+     * @param data - Request body data
+     * @param config - Optional request configuration
+     * @returns Promise resolving to ApiResponse
+     *
+     * @example
+     * ```typescript
+     * const { apiData, error } = await client.patch<User>(
+     *   '/users/123',
+     *   { status: 'active' }
+     * );
+     * ```
+     */
+    patch<T = ResponseData, TData extends BodyInit | Record<string, unknown> | null = Record<string, unknown>>(endpoint: string, data?: TData, config?: RequestConfig): Promise<ApiResponse<T, ApiError>>;
+    /**
+     * Performs a DELETE request
+     * @template T - The expected response data type
+     * @param endpoint - API endpoint
+     * @param config - Optional request configuration
+     * @returns Promise resolving to ApiResponse
+     *
+     * @example
+     * ```typescript
+     * const { error } = await client.delete('/users/123');
+     * if (!error) {
+     *   console.log('User deleted successfully');
+     * }
+     * ```
+     */
+    delete<T = ResponseData>(endpoint: string, config?: RequestConfig): Promise<ApiResponse<T, ApiError>>;
+    /**
+     * Performs a filtered list request with pagination and sorting
+     * @template TListModel - The type of individual list items
+     * @template TFilter - The filter criteria type
+     * @param url - API endpoint
+     * @param data - Pagination and filter data
+     * @param config - Optional request configuration
+     * @returns Promise resolving to paginated list response
+     *
+     * @example
+     * ```typescript
+     * const { apiData, error } = await client.filter<User, UserFilter>(
+     *   '/users/filter',
+     *   {
+     *     pageOffset: 0,
+     *     pageSize: 20,
+     *     sortField: 'createdAt',
+     *     sortOrder: 'desc',
+     *     filterModel: { status: 'active' }
+     *   }
+     * );
+     *
+     * if (apiData) {
+     *   console.log(`Found ${apiData.Total} users`);
+     *   console.log('Users:', apiData.Data);
+     * }
+     * ```
+     */
+    filter<TListModel, TFilter = Record<string, unknown>>(url: string, data: PostModel<TFilter>, config?: RequestConfig): Promise<ApiResponse<ListResponse<TListModel>, ApiError>>;
+}
+//# sourceMappingURL=ApiClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ApiClient.d.ts","sourceRoot":"","sources":["../../../src/core/api/ApiClient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EAET,YAAY,EACb,MAAM,UAAU,CAAC;AAIlB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAIvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CACR;IAC3B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsC;IACpE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0C;IAC1E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwC;IACvE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAC3D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoC;IACjE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwC;IACvE,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,mBAAmB,CAAiB;IAC5C,OAAO,CAAC,oBAAoB,CAAiB;IAE7C;;;;OAIG;gBACS,OAAO,GAAE,MAAW,EAAE,cAAc,GAAE,MAAc;IAKhE;;;OAGG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI5C;;;OAGG;IACH,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI/C;;;;;;;;;;;;;;;;OAgBG;IACH,qBAAqB,CAAC,WAAW,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAIlE;;;;;;;;;;;;;;;OAeG;IACH,sBAAsB,CAAC,WAAW,EAAE,mBAAmB,GAAG,MAAM,IAAI;IAIpE;;;;;;;;;;;;;;;OAeG;IACH,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAI9D;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAIxC;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B;;;OAGG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIhC;;;OAGG;IACH,iBAAiB,IAAI,IAAI;IAIzB;;;;;;;;;;;;;;;OAeG;IACG,OAAO,CAAC,CAAC,GAAG,YAAY,EAC5B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,aAAkB,GACzB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAoNpC;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,CAAC,GAAG,YAAY,EAClB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CACF,CAAC,GAAG,YAAY,EAChB,KAAK,SAAS,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,MAAM,CAC9D,MAAM,EACN,OAAO,CACR,EAED,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,CACD,CAAC,GAAG,YAAY,EAChB,KAAK,SAAS,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,MAAM,CAC9D,MAAM,EACN,OAAO,CACR,EAED,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CACH,CAAC,GAAG,YAAY,EAChB,KAAK,SAAS,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,MAAM,CAC9D,MAAM,EACN,OAAO,CACR,EAED,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAQpC;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,CAAC,GAAG,YAAY,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClD,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,SAAS,CAAC,OAAO,CAAC,EACxB,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;CAU5D"}

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

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Utilities for generating correlation IDs for distributed request tracing.
+ *
+ * Correlation IDs are unique identifiers attached to each API request to enable
+ * tracking and debugging across distributed systems, microservices, and log aggregation.
+ *
+ * @module CorrelationIdGenerator
+ */
+/**
+ * Generates a unique correlation ID for API request tracking and distributed tracing.
+ *
+ * Correlation IDs help track requests across multiple services and systems. They are
+ * automatically attached to outgoing requests via HTTP headers (`X-Correlation-Id` and
+ * `X-Request-Id`) and can be used to:
+ * - Correlate logs across distributed systems
+ * - Track request flows in microservices architectures
+ * - Debug issues by tracing a specific request's journey
+ * - Monitor performance across service boundaries
+ *
+ * The generated ID follows the format: `{prefix}-{uuid}` or just `{uuid}` if no prefix is provided.
+ *
+ * @param prefix - Optional prefix to namespace correlation IDs by context (e.g., 'api', 'web', 'mobile')
+ * @returns A correlation ID string, optionally prefixed
+ * @public
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const id = generateCorrelationId();
+ * // => "a1b2c3d4-e5f6-4789-a012-b3c4d5e6f7a8"
+ * ```
+ *
+ * @example
+ * With prefix for context identification:
+ * ```typescript
+ * const webId = generateCorrelationId('web');
+ * // => "web-a1b2c3d4-e5f6-4789-a012-b3c4d5e6f7a8"
+ *
+ * const apiId = generateCorrelationId('api');
+ * // => "api-f1e2d3c4-b5a6-4987-a012-b3c4d5e6f7a8"
+ * ```
+ *
+ * @example
+ * Configuring in ApiClient:
+ * ```typescript
+ * const client = new ApiClient('https://api.example.com');
+ * client.setCorrelationIdPrefix('mobile');
+ * // All requests will have correlation IDs like "mobile-{uuid}"
+ * ```
+ */
+export declare function generateCorrelationId(prefix?: string): string;
+//# sourceMappingURL=CorrelationIdGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CorrelationIdGenerator.d.ts","sourceRoot":"","sources":["../../../src/core/api/CorrelationIdGenerator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA+BH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAI7D"}

package/dist/core/api/Errors/ErrorNormalizer.d.ts

@@ -0,0 +1,106 @@
+import type { ApiError, ApiErrorType } from '../types/ApiError';
+import type { RequestConfig } from '../types/RequestConfig';
+/**
+ * Normalizes various error types into a consistent, structured ApiError format.
+ *
+ * This internal class handles the complex task of converting any type of error
+ * (network errors, HTTP errors, abort errors, timeouts, etc.) into a standardized
+ * {@link ApiError} structure with proper categorization and metadata.
+ *
+ * Key Features:
+ * - **Error Categorization**: Classifies errors by type (validation, client, server, network, etc.)
+ * - **HTTP Status Mapping**: Converts status codes to human-readable titles
+ * - **Correlation ID Tracking**: Preserves or injects correlation IDs for tracing
+ * - **Abort Detection**: Identifies and properly handles request cancellations
+ * - **Consistent Structure**: Ensures all errors conform to the ApiError interface
+ *
+ * @internal This class is not exported from the public API
+ */
+export declare class ErrorNormalizer {
+    /**
+     * Maps an HTTP status code to a standardized error type category.
+     *
+     * This categorization helps consumers handle different error classes appropriately:
+     * - `validation_error` (400): Client sent invalid data
+     * - `client_error` (401-499): Client-side issues (auth, permissions, not found, etc.)
+     * - `server_error` (500-599): Server-side failures
+     * - `unknown_error`: Unrecognized status codes
+     *
+     * @param status - HTTP status code from the response
+     * @returns The error type category as a string
+     *
+     * @example
+     * ```typescript
+     * normalizer.getErrorType(400); // => 'validation_error'
+     * normalizer.getErrorType(404); // => 'client_error'
+     * normalizer.getErrorType(500); // => 'server_error'
+     * normalizer.getErrorType(0);   // => 'unknown_error'
+     * ```
+     */
+    getErrorType(status: number): ApiErrorType;
+    /**
+     * Maps an HTTP status code to a human-readable error title.
+     *
+     * Provides user-friendly error messages for common HTTP status codes.
+     * Falls back to a generic "HTTP Error {status}" format for unmapped codes.
+     *
+     * @param status - HTTP status code from the response
+     * @returns A human-readable error title
+     *
+     * @example
+     * ```typescript
+     * normalizer.getErrorTitle(404); // => 'Not Found'
+     * normalizer.getErrorTitle(500); // => 'Internal Server Error'
+     * normalizer.getErrorTitle(999); // => 'HTTP Error 999'
+     * ```
+     */
+    getErrorTitle(status: number): string;
+    /**
+     * Normalizes any error into a consistent, structured ApiError format.
+     *
+     * This method handles various error scenarios and ensures they all conform to
+     * the {@link ApiError} interface with appropriate categorization and metadata:
+     *
+     * - **Existing ApiErrors**: Enhances with missing fields (traceId, config)
+     * - **AbortErrors**: Marks as `request_cancelled` with isAborted flag
+     * - **Timeout Errors**: Categorizes as `timeout_error` with 408 status
+     * - **Network Errors**: Categorizes as `network_error` with 0 status
+     * - **Unknown Errors**: Fallback category for unexpected error types
+     *
+     * All normalized errors include:
+     * - `type`: Error category for programmatic handling
+     * - `title`: Human-readable error title
+     * - `status`: HTTP status code (or 0 for non-HTTP errors)
+     * - `traceId`: Correlation ID for distributed tracing
+     * - `isAborted`: Boolean flag indicating if request was cancelled
+     * - `config`: Original request configuration for debugging
+     *
+     * @param error - The error to normalize (can be any type)
+     * @param config - The request configuration that led to this error
+     * @param correlationId - Optional correlation ID for tracing
+     * @returns A fully structured ApiError instance
+     *
+     * @example
+     * Normalizing a fetch AbortError:
+     * ```typescript
+     * try {
+     *   await fetch(url, { signal });
+     * } catch (error) {
+     *   const apiError = normalizer.normalizeError(error, config, 'req-123');
+     *   // apiError.type === 'request_cancelled'
+     *   // apiError.isAborted === true
+     * }
+     * ```
+     *
+     * @example
+     * Normalizing a timeout:
+     * ```typescript
+     * const timeoutError = new Error('Request timeout after 30000ms');
+     * const apiError = normalizer.normalizeError(timeoutError, config);
+     * // apiError.type === 'timeout_error'
+     * // apiError.status === 408
+     * ```
+     */
+    normalizeError(error: unknown, config: RequestConfig, correlationId?: string): ApiError;
+}
+//# sourceMappingURL=ErrorNormalizer.d.ts.map

package/dist/core/api/Errors/ErrorNormalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorNormalizer.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Errors/ErrorNormalizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAe;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAU1C;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAoBrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,cAAc,CACZ,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,aAAa,EACrB,aAAa,CAAC,EAAE,MAAM,GACrB,QAAQ;CAwFZ"}