@gnwebsoft/ui 4.0.2 → 4.0.4

package/dist/core/api/Signals/SignalManager.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Manages AbortSignal creation and composition for request cancellation and timeouts.
+ *
+ * This internal class provides utilities for working with the AbortSignal API,
+ * enabling sophisticated cancellation patterns by combining multiple cancellation
+ * sources and creating timeout-based signals.
+ *
+ * Key Features:
+ * - **Signal Composition**: Combine multiple AbortSignals into one
+ * - **Timeout Signals**: Create signals that auto-abort after a delay
+ * - **Early Abort Detection**: Immediately abort if any source is already aborted
+ * - **Resource Cleanup**: Automatic timeout cleanup on abort
+ *
+ * Use Cases:
+ * - Combine user cancellation + timeout + component unmount signals
+ * - Create request deadlines
+ * - Implement cascading cancellation
+ *
+ * @internal This class is not exported from the public API
+ *
+ * @example
+ * Combining multiple cancellation sources:
+ * ```typescript
+ * const manager = new SignalManager();
+ * const userCancel = new AbortController();
+ * const unmountSignal = componentUnmountSignal;
+ *
+ * // Request will be cancelled if either user clicks cancel OR component unmounts
+ * const combined = manager.createCombinedSignal([
+ *   userCancel.signal,
+ *   unmountSignal
+ * ]);
+ *
+ * fetch('/api/data', { signal: combined.signal });
+ * ```
+ */
+export declare class SignalManager {
+    /**
+     * Creates a combined AbortController that aborts when any source signal aborts.
+     *
+     * This method implements the "any" pattern for cancellation: the combined signal
+     * will abort as soon as ANY of the source signals abort. This is useful for
+     * coordinating multiple cancellation conditions:
+     * - User clicks cancel button
+     * - Request timeout expires
+     * - Component unmounts
+     * - Parent request is cancelled
+     *
+     * **Early Abort Optimization:**
+     * If any source signal is already aborted when this method is called,
+     * the returned controller is immediately aborted without setting up listeners.
+     *
+     * **Memory Management:**
+     * Event listeners are registered with `{ once: true }` to prevent memory leaks,
+     * as they automatically clean up after firing.
+     *
+     * @param signals - Array of AbortSignals to combine (undefined values are ignored)
+     * @returns A new AbortController that aborts when any source signal aborts
+     *
+     * @example
+     * User cancellation + timeout:
+     * ```typescript
+     * const userController = new AbortController();
+     * const timeout = manager.createTimeoutSignal(30000);
+     *
+     * const combined = manager.createCombinedSignal([
+     *   userController.signal,
+     *   timeout.signal
+     * ]);
+     *
+     * // Request will be cancelled after 30s OR when user clicks cancel
+     * fetch('/api/data', { signal: combined.signal });
+     * ```
+     *
+     * @example
+     * React component with cleanup:
+     * ```typescript
+     * useEffect(() => {
+     *   const controller = new AbortController();
+     *
+     *   const combined = manager.createCombinedSignal([
+     *     controller.signal,
+     *     unmountSignal  // From component lifecycle
+     *   ]);
+     *
+     *   fetchData(combined.signal);
+     *
+     *   return () => controller.abort(); // Cleanup
+     * }, []);
+     * ```
+     */
+    createCombinedSignal(signals: Array<AbortSignal | undefined>): AbortController;
+    /**
+     * Creates an AbortController that automatically aborts after a specified timeout.
+     *
+     * This method creates a time-based cancellation mechanism useful for implementing
+     * request timeouts and deadlines. The signal will automatically abort after the
+     * specified duration, providing a consistent timeout experience.
+     *
+     * **Automatic Cleanup:**
+     * If the signal is aborted by other means before the timeout expires, the internal
+     * setTimeout is automatically cleared to prevent memory leaks.
+     *
+     * **Abort Reason:**
+     * The abort reason includes the timeout duration for debugging purposes:
+     * `"Request timeout after {timeout}ms"`
+     *
+     * @param timeout - Timeout duration in milliseconds
+     * @returns An AbortController that will abort after the timeout
+     *
+     * @example
+     * Simple request timeout:
+     * ```typescript
+     * const manager = new SignalManager();
+     * const timeout = manager.createTimeoutSignal(5000); // 5 seconds
+     *
+     * try {
+     *   const response = await fetch('/api/slow-endpoint', {
+     *     signal: timeout.signal
+     *   });
+     *   const data = await response.json();
+     * } catch (error) {
+     *   if (error.name === 'AbortError') {
+     *     console.error('Request timed out after 5 seconds');
+     *   }
+     * }
+     * ```
+     *
+     * @example
+     * Different timeouts for different operations:
+     * ```typescript
+     * // Short timeout for quick operations
+     * const quickTimeout = manager.createTimeoutSignal(2000);
+     * await fetch('/api/health', { signal: quickTimeout.signal });
+     *
+     * // Long timeout for heavy operations
+     * const longTimeout = manager.createTimeoutSignal(60000);
+     * await fetch('/api/export', { signal: longTimeout.signal });
+     * ```
+     *
+     * @example
+     * Manual cancellation before timeout:
+     * ```typescript
+     * const timeout = manager.createTimeoutSignal(30000);
+     *
+     * // If user cancels, timeout is automatically cleaned up
+     * timeout.abort('User cancelled');
+     * // Internal setTimeout is cleared, no memory leak
+     * ```
+     */
+    createTimeoutSignal(timeout: number): AbortController;
+}
+//# sourceMappingURL=SignalManager.d.ts.map

package/dist/core/api/Signals/SignalManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignalManager.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Signals/SignalManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;IACH,oBAAoB,CAClB,OAAO,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAC,GACtC,eAAe;IAuBlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyDG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;CAkBtD"}

package/dist/core/api/Utils/ResponseParser.d.ts

@@ -0,0 +1,105 @@
+import type { ResponseData } from '../Models';
+/**
+ * Parses HTTP response bodies into appropriate JavaScript types based on Content-Type headers.
+ *
+ * This internal class handles the complexity of converting various HTTP response formats
+ * into usable JavaScript data structures. It intelligently detects the response type
+ * and applies the appropriate parsing strategy.
+ *
+ * Supported Content Types:
+ * - **application/json**: Parsed as JSON objects/arrays
+ * - **text/*** (text/plain, text/html, etc.): Returned as string
+ * - **application/octet-stream**: Returned as Blob for binary data
+ * - **Unknown/Missing**: Attempts JSON parse, falls back to text
+ *
+ * Key Features:
+ * - **Automatic Detection**: Uses Content-Type header to determine parsing strategy
+ * - **Graceful Fallback**: Attempts JSON parsing for unknown types, falls back to text
+ * - **Binary Support**: Handles binary data via Blob
+ * - **Type Safety**: Returns typed ResponseData union
+ *
+ * @internal This class is not exported from the public API
+ *
+ * @example
+ * Parsing different response types:
+ * ```typescript
+ * const parser = new ResponseParser();
+ *
+ * // JSON response
+ * const jsonResponse = new Response('{"id": 1}', {
+ *   headers: { 'Content-Type': 'application/json' }
+ * });
+ * const data = await parser.parseResponse(jsonResponse);
+ * // => { id: 1 }
+ *
+ * // Text response
+ * const textResponse = new Response('Hello World', {
+ *   headers: { 'Content-Type': 'text/plain' }
+ * });
+ * const text = await parser.parseResponse(textResponse);
+ * // => "Hello World"
+ *
+ * // Binary response
+ * const blobResponse = new Response(binaryData, {
+ *   headers: { 'Content-Type': 'application/octet-stream' }
+ * });
+ * const blob = await parser.parseResponse(blobResponse);
+ * // => Blob { ... }
+ * ```
+ */
+export declare class ResponseParser {
+    /**
+     * Parses the HTTP response body into an appropriate JavaScript type.
+     *
+     * The parsing strategy is determined by the Content-Type header:
+     * 1. **JSON** (application/json): Calls `response.json()`
+     * 2. **Text** (text/*): Calls `response.text()`
+     * 3. **Binary** (application/octet-stream): Calls `response.blob()`
+     * 4. **Unknown**: Reads as text, attempts JSON parse, falls back to raw text
+     *
+     * **Fallback Behavior:**
+     * For responses without a Content-Type header or with unknown types, the parser
+     * attempts to parse as JSON first (common for APIs that don't set proper headers).
+     * If JSON parsing fails, it returns the raw text.
+     *
+     * @param response - The Fetch API Response object to parse
+     * @returns Promise resolving to the parsed response data
+     * @returns Can be: JSON object/array, string, or Blob depending on Content-Type
+     *
+     * @example
+     * API response parsing:
+     * ```typescript
+     * const response = await fetch('/api/users');
+     * const data = await parser.parseResponse(response);
+     *
+     * if (typeof data === 'string') {
+     *   console.log('Text response:', data);
+     * } else if (data instanceof Blob) {
+     *   console.log('Binary response:', data.size, 'bytes');
+     * } else {
+     *   console.log('JSON response:', data);
+     * }
+     * ```
+     *
+     * @example
+     * Handling different content types:
+     * ```typescript
+     * // CSV file download
+     * const csvResponse = await fetch('/api/export.csv');
+     * const blob = await parser.parseResponse(csvResponse);
+     * // Returns Blob for download
+     *
+     * // JSON API
+     * const jsonResponse = await fetch('/api/users');
+     * const users = await parser.parseResponse(jsonResponse);
+     * // Returns parsed JSON array
+     *
+     * // Plain text logs
+     * const logResponse = await fetch('/api/logs');
+     * const logs = await parser.parseResponse(logResponse);
+     * // Returns string
+     * ```
+     */
+    parseResponse(response: Response): Promise<ResponseData>;
+}
+//# sourceMappingURL=ResponseParser.d.ts.map

package/dist/core/api/Utils/ResponseParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResponseParser.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Utils/ResponseParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,cAAc;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACG,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC;CAoB/D"}

package/dist/core/api/Utils/UrlBuilder.d.ts

@@ -0,0 +1,111 @@
+import type { QueryParams } from '../Models';
+/**
+ * Constructs fully-qualified URLs with proper query parameter encoding.
+ *
+ * This internal class handles the complexity of URL construction, combining
+ * base URLs, endpoints, and query parameters with proper encoding and array
+ * handling. It uses the native URL API for reliable URL composition.
+ *
+ * Key Features:
+ * - **URL Composition**: Safely combines base URL and endpoint paths
+ * - **Query Parameter Encoding**: Automatic encoding of special characters
+ * - **Array Support**: Handles array parameters with multiple values
+ * - **Null/Undefined Filtering**: Automatically skips null/undefined values
+ * - **Type Safety**: Strongly typed query parameter values
+ *
+ * Array Handling:
+ * Array parameters are serialized by appending the same key multiple times:
+ * `?tags=javascript&tags=typescript&tags=react`
+ *
+ * @internal This class is not exported from the public API
+ *
+ * @example
+ * Building URLs with query parameters:
+ * ```typescript
+ * const builder = new UrlBuilder();
+ *
+ * const url = builder.buildURL(
+ *   'https://api.example.com',
+ *   '/users',
+ *   { active: true, role: 'admin', page: 1 }
+ * );
+ * // => "https://api.example.com/users?active=true&role=admin&page=1"
+ * ```
+ */
+export declare class UrlBuilder {
+    /**
+     * Builds a complete URL by combining base URL, endpoint, and query parameters.
+     *
+     * The URL construction process:
+     * 1. Combines `baseURL` and `endpoint` using URL API
+     * 2. Iterates through query parameters
+     * 3. Skips null/undefined values
+     * 4. Handles arrays by appending multiple values with same key
+     * 5. Converts all values to strings
+     * 6. Returns fully-qualified URL string
+     *
+     * **Path Handling:**
+     * The endpoint can be either relative or absolute:
+     * - Relative: `/users` → Combined with baseURL
+     * - Absolute: `https://other-api.com/users` → Uses absolute URL
+     *
+     * **Encoding:**
+     * All parameter values are automatically URL-encoded by the URL API,
+     * so special characters (spaces, &, =, etc.) are safely handled.
+     *
+     * @param baseURL - Base URL for the API (e.g., 'https://api.example.com')
+     * @param endpoint - API endpoint path relative to baseURL (e.g., '/users/123')
+     * @param params - Optional query parameters as key-value pairs
+     * @returns The fully-qualified URL string with encoded query parameters
+     *
+     * @example
+     * Basic URL construction:
+     * ```typescript
+     * const url = builder.buildURL(
+     *   'https://api.example.com',
+     *   '/search',
+     *   { q: 'hello world', limit: 10 }
+     * );
+     * // => "https://api.example.com/search?q=hello+world&limit=10"
+     * ```
+     *
+     * @example
+     * Array parameters:
+     * ```typescript
+     * const url = builder.buildURL(
+     *   'https://api.example.com',
+     *   '/posts',
+     *   { tags: ['javascript', 'typescript', 'react'] }
+     * );
+     * // => "https://api.example.com/posts?tags=javascript&tags=typescript&tags=react"
+     * ```
+     *
+     * @example
+     * Null/undefined handling:
+     * ```typescript
+     * const url = builder.buildURL(
+     *   'https://api.example.com',
+     *   '/users',
+     *   {
+     *     name: 'John',
+     *     age: null,        // Skipped
+     *     email: undefined  // Skipped
+     *   }
+     * );
+     * // => "https://api.example.com/users?name=John"
+     * ```
+     *
+     * @example
+     * Special characters encoding:
+     * ```typescript
+     * const url = builder.buildURL(
+     *   'https://api.example.com',
+     *   '/search',
+     *   { q: 'foo & bar', category: 'code/examples' }
+     * );
+     * // => "https://api.example.com/search?q=foo+%26+bar&category=code%2Fexamples"
+     * ```
+     */
+    buildURL(baseURL: string, endpoint: string, params?: QueryParams): string;
+}
+//# sourceMappingURL=UrlBuilder.d.ts.map

package/dist/core/api/Utils/UrlBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UrlBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/api/Utils/UrlBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM;CAmB1E"}

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

@@ -0,0 +1,243 @@
+/**
+ * @fileoverview Factory functions for creating and managing ApiClient instances.
+ *
+ * Provides convenient factory methods for creating pre-configured ApiClient instances
+ * with sensible defaults and automatic token management from localStorage.
+ *
+ * @module createApiClient
+ */
+import { ApiClient } from './ApiClient';
+import type { ErrorInterceptor } from './types/ErrorInterceptor';
+import type { RequestInterceptor } from './types/RequestInterceptor';
+import type { ResponseInterceptor } from './types/ResponseInterceptor';
+/**
+ * Configuration options for creating an ApiClient instance.
+ *
+ * @public
+ */
+export interface ApiClientConfig {
+    /**
+     * Base URL for all API requests.
+     * @example 'https://api.example.com'
+     */
+    baseURL?: string;
+    /**
+     * Default timeout for requests in milliseconds.
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Prefix for auto-generated correlation IDs (e.g., 'api', 'web', 'mobile').
+     * @default 'api'
+     */
+    correlationIdPrefix?: string;
+    /**
+     * Whether to automatically generate and include correlation IDs in requests.
+     * @default true
+     */
+    includeCorrelationId?: boolean;
+    /**
+     * Initial authentication token to set on the client.
+     * @default undefined
+     */
+    authToken?: string | null;
+    /**
+     * Array of request interceptors to register during client creation.
+     * @default []
+     */
+    requestInterceptors?: RequestInterceptor[];
+    /**
+     * Array of response interceptors to register during client creation.
+     * @default []
+     */
+    responseInterceptors?: ResponseInterceptor[];
+    /**
+     * Array of error interceptors to register during client creation.
+     * @default []
+     */
+    errorInterceptors?: ErrorInterceptor[];
+}
+/**
+ * Creates a new ApiClient instance with sensible defaults and automatic token management.
+ *
+ * This factory function:
+ * - Configures the base URL from environment variables or config
+ * - Sets up automatic authentication token injection from localStorage ('serviceToken' key)
+ * - Configures correlation ID generation
+ * - Registers provided interceptors
+ *
+ * **Note:** Each call creates a NEW instance. Use {@link getGlobalApiClient} for singleton behavior.
+ *
+ * @param config - Configuration options for the API client
+ * @returns A fully configured ApiClient instance
+ * @public
+ *
+ * @example
+ * Basic usage with defaults:
+ * ```typescript
+ * const client = createApiClient();
+ * // Uses VITE_API_URL, 30s timeout, auto token from localStorage
+ * ```
+ *
+ * @example
+ * Custom configuration:
+ * ```typescript
+ * const client = createApiClient({
+ *   baseURL: 'https://api.example.com',
+ *   timeout: 60000,
+ *   correlationIdPrefix: 'web',
+ *   requestInterceptors: [
+ *     async (config) => {
+ *       console.log('Making request:', config.url);
+ *       return config;
+ *     }
+ *   ]
+ * });
+ * ```
+ *
+ * @example
+ * With React Query:
+ * ```typescript
+ * const apiClient = createApiClient({
+ *   baseURL: process.env.REACT_APP_API_URL
+ * });
+ *
+ * const queryClient = new QueryClient();
+ *
+ * function UserProfile({ userId }) {
+ *   const { data: response } = useQuery({
+ *     queryKey: ['user', userId],
+ *     queryFn: () => apiClient.get(`/users/${userId}`)
+ *   });
+ *   const user = response?.apiData; // Access the actual data
+ *   // ...
+ * }
+ * ```
+ */
+export declare function createApiClient(config?: ApiClientConfig): ApiClient;
+/**
+ * Gets or creates a global singleton ApiClient instance.
+ *
+ * This function implements the singleton pattern for ApiClient. It creates the client
+ * on first call and returns the same instance on subsequent calls. This is useful for:
+ * - Sharing the same client across your entire application
+ * - Avoiding multiple instances with different configurations
+ * - Consistent interceptor behavior app-wide
+ *
+ * **Important:** The config parameter is only used on the FIRST call. Subsequent calls
+ * ignore the config and return the existing instance. Use {@link resetGlobalApiClient}
+ * first if you need to recreate with different config.
+ *
+ * @param config - Configuration options (only used on first call)
+ * @returns The global ApiClient singleton instance
+ * @public
+ *
+ * @example
+ * In your app initialization:
+ * ```typescript
+ * // src/lib/api.ts
+ * export const apiClient = getGlobalApiClient({
+ *   baseURL: 'https://api.example.com',
+ *   timeout: 30000
+ * });
+ * ```
+ *
+ * @example
+ * Import and use throughout your app:
+ * ```typescript
+ * // src/features/users/api.ts
+ * import { getGlobalApiClient } from '@gnwebsoft/ui';
+ *
+ * const client = getGlobalApiClient(); // Returns same instance
+ *
+ * export async function fetchUsers() {
+ *   const { apiData } = await client.get('/users');
+ *   return apiData;
+ * }
+ * ```
+ *
+ * @example
+ * Resetting for tests:
+ * ```typescript
+ * afterEach(() => {
+ *   resetGlobalApiClient();
+ * });
+ *
+ * test('creates fresh client', () => {
+ *   const client = getGlobalApiClient({ baseURL: 'http://test.local' });
+ *   // New instance with test config
+ * });
+ * ```
+ */
+export declare function getGlobalApiClient(config?: ApiClientConfig): ApiClient;
+/**
+ * Replaces the global singleton ApiClient with a custom instance.
+ *
+ * Use this when you need fine-grained control over the global client instance,
+ * such as in testing scenarios or when you've manually created a client with
+ * specific configuration.
+ *
+ * @param client - The ApiClient instance to use as the global singleton
+ * @public
+ *
+ * @example
+ * Testing with a mock client:
+ * ```typescript
+ * const mockClient = new ApiClient('http://test.local');
+ * mockClient.addResponseInterceptor(async (response) => {
+ *   // Mock response data
+ *   return { data: mockData };
+ * });
+ *
+ * setGlobalApiClient(mockClient);
+ * ```
+ *
+ * @example
+ * Advanced configuration:
+ * ```typescript
+ * const client = new ApiClient('https://api.example.com', 60000);
+ * client.setCorrelationIdPrefix('custom');
+ * client.addRequestInterceptor(customInterceptor);
+ *
+ * setGlobalApiClient(client);
+ * ```
+ */
+export declare function setGlobalApiClient(client: ApiClient): void;
+/**
+ * Resets the global ApiClient singleton to null.
+ *
+ * After calling this, the next call to {@link getGlobalApiClient} will create
+ * a fresh instance. This is particularly useful in:
+ * - Test cleanup to ensure test isolation
+ * - Application logout to clear any cached state
+ * - Hot module reloading during development
+ *
+ * @public
+ *
+ * @example
+ * Test cleanup:
+ * ```typescript
+ * afterEach(() => {
+ *   resetGlobalApiClient();
+ * });
+ * ```
+ *
+ * @example
+ * Logout flow:
+ * ```typescript
+ * function handleLogout() {
+ *   // Clear authentication
+ *   localStorage.removeItem('serviceToken');
+ *
+ *   // Cancel all pending requests and reset client
+ *   const client = getGlobalApiClient();
+ *   client.cancelAllRequests();
+ *   resetGlobalApiClient();
+ *
+ *   // Redirect to login
+ *   navigate('/login');
+ * }
+ * ```
+ */
+export declare function resetGlobalApiClient(): void;
+//# sourceMappingURL=createApiClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createApiClient.d.ts","sourceRoot":"","sources":["../../../src/core/api/createApiClient.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAE3C;;;OAGG;IACH,oBAAoB,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAE7C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACxC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,eAAe,CAAC,MAAM,GAAE,eAAoB,GAAG,SAAS,CAiDvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,SAAS,CAMtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}

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

@@ -0,0 +1,7 @@
+export * from './ApiClient';
+export * from './CorrelationIdGenerator';
+export * from './RequestManager';
+export * from './createApiClient';
+export * from './types';
+export * from './useValidationErrors';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAE5B,cAAc,0BAA0B,CAAC;AAEzC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,mBAAmB,CAAC;AAElC,cAAc,SAAS,CAAC;AAExB,cAAc,uBAAuB,CAAC"}

package/dist/core/api/types/ApiError.d.ts

@@ -0,0 +1,17 @@
+import type { RequestConfig } from './RequestConfig';
+import type { ValidationErrors } from './ValidationErrors';
+/**
+ * Union type for all possible API error categories.
+ * Used for consistent error type handling across the API client.
+ */
+export type ApiErrorType = 'validation_error' | 'client_error' | 'server_error' | 'request_cancelled' | 'timeout_error' | 'network_error' | 'unknown_error';
+export interface ApiError extends Error {
+    type?: ApiErrorType;
+    title?: string;
+    status?: number;
+    traceId?: string;
+    errors?: ValidationErrors;
+    isAborted?: boolean;
+    config?: RequestConfig;
+}
+//# sourceMappingURL=ApiError.d.ts.map

package/dist/core/api/types/ApiError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiError.d.ts","sourceRoot":"","sources":["../../../../src/core/api/types/ApiError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,mBAAmB,GACnB,eAAe,GACf,eAAe,GACf,eAAe,CAAC;AAEpB,MAAM,WAAW,QAAS,SAAQ,KAAK;IACrC,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}