@gnwebsoft/ui 4.0.2 → 4.0.3

package/dist/chunk-YAYXHYKC.js

@@ -0,0 +1,2512 @@
+// src/core/api/CorrelationIdGenerator.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateCorrelationId(prefix) {
+  const uuid = generateUUID();
+  return prefix ? `${prefix}-${uuid}` : uuid;
+}
+
+// src/core/api/Errors/ErrorNormalizer.ts
+var ErrorNormalizer = class {
+  /**
+   * 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) {
+    if (status >= 400 && status < 500) {
+      return status === 400 ? "validation_error" : "client_error";
+    } else if (status >= 500) {
+      return "server_error";
+    }
+    return "unknown_error";
+  }
+  /**
+   * 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) {
+    const titles = {
+      400: "Bad Request",
+      401: "Unauthorized",
+      403: "Forbidden",
+      404: "Not Found",
+      405: "Method Not Allowed",
+      408: "Request Timeout",
+      409: "Conflict",
+      422: "Unprocessable Entity",
+      429: "Too Many Requests",
+      500: "Internal Server Error",
+      502: "Bad Gateway",
+      503: "Service Unavailable",
+      504: "Gateway Timeout"
+    };
+    return titles[status] || `HTTP Error ${status}`;
+  }
+  /**
+   * 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, config, correlationId) {
+    if (error === null || error === void 0) {
+      return Object.assign(new Error("An unknown error occurred"), {
+        type: "unknown_error",
+        title: "Unknown Error",
+        status: 0,
+        traceId: correlationId,
+        isAborted: false,
+        config
+      });
+    }
+    if (typeof error === "string") {
+      return Object.assign(new Error(error), {
+        type: "unknown_error",
+        title: "Unknown Error",
+        status: 0,
+        traceId: correlationId,
+        isAborted: false,
+        config
+      });
+    }
+    const err = error;
+    if (err.type || err.title || err.errors) {
+      return Object.assign(
+        error instanceof Error ? error : new Error(err.message ?? "Unknown error"),
+        {
+          type: err.type,
+          title: err.title,
+          status: err.status,
+          traceId: err.traceId || correlationId,
+          errors: err.errors,
+          isAborted: err.isAborted || false,
+          config
+        }
+      );
+    }
+    if (err.name === "AbortError" || err.isAborted) {
+      return Object.assign(new Error(err.message ?? "Request was aborted"), {
+        type: "request_cancelled",
+        title: "Request was cancelled",
+        status: 0,
+        traceId: correlationId,
+        isAborted: true,
+        config
+      });
+    }
+    if (err.message?.includes("timeout")) {
+      return Object.assign(new Error(err.message), {
+        type: "timeout_error",
+        title: "Request Timeout",
+        status: 408,
+        traceId: correlationId,
+        isAborted: true,
+        config
+      });
+    }
+    if (err.message?.includes("network")) {
+      return Object.assign(new Error(err.message ?? "Network request failed"), {
+        type: "network_error",
+        title: "Network Error",
+        status: 0,
+        traceId: correlationId,
+        isAborted: false,
+        config
+      });
+    }
+    return Object.assign(
+      new Error(err.message ?? "An unknown error occurred"),
+      {
+        type: "unknown_error",
+        title: "Unknown Error",
+        status: 0,
+        traceId: correlationId,
+        isAborted: false,
+        config
+      }
+    );
+  }
+};
+
+// src/core/api/Interceptors/InterceptorManager.ts
+var InterceptorManager = class {
+  /**
+   * Array of registered request interceptors
+   * @private
+   */
+  requestInterceptors = [];
+  /**
+   * Array of registered response interceptors
+   * @private
+   */
+  responseInterceptors = [];
+  /**
+   * Array of registered error interceptors
+   * @private
+   */
+  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) {
+    this.requestInterceptors.push(interceptor);
+    return () => {
+      const index = this.requestInterceptors.indexOf(interceptor);
+      if (index > -1) this.requestInterceptors.splice(index, 1);
+    };
+  }
+  /**
+   * 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) {
+    this.responseInterceptors.push(interceptor);
+    return () => {
+      const index = this.responseInterceptors.indexOf(interceptor);
+      if (index > -1) this.responseInterceptors.splice(index, 1);
+    };
+  }
+  /**
+   * 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) {
+    this.errorInterceptors.push(interceptor);
+    return () => {
+      const index = this.errorInterceptors.indexOf(interceptor);
+      if (index > -1) this.errorInterceptors.splice(index, 1);
+    };
+  }
+  /**
+   * 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
+   * ```
+   */
+  async applyRequestInterceptors(config) {
+    let modifiedConfig = { ...config };
+    for (const interceptor of this.requestInterceptors) {
+      modifiedConfig = await interceptor(modifiedConfig);
+    }
+    return modifiedConfig;
+  }
+  /**
+   * 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
+   * ```
+   */
+  async applyResponseInterceptors(response) {
+    let modifiedResponse = response;
+    for (const interceptor of this.responseInterceptors) {
+      modifiedResponse = await interceptor(modifiedResponse);
+    }
+    return modifiedResponse;
+  }
+  /**
+   * 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
+   * }
+   * ```
+   */
+  async applyErrorInterceptors(error) {
+    let modifiedError = error;
+    for (const interceptor of this.errorInterceptors) {
+      try {
+        modifiedError = await interceptor(modifiedError);
+      } catch (e) {
+        modifiedError = e;
+      }
+    }
+    throw modifiedError;
+  }
+};
+
+// src/core/api/RequestManager.ts
+var RequestManager = class {
+  /**
+   * Map of active request keys to their abort controllers
+   * @private
+   */
+  activeRequests = /* @__PURE__ */ new Map();
+  /**
+   * Map of request keys to their correlation IDs for tracing
+   * @private
+   */
+  correlationMap = /* @__PURE__ */ new Map();
+  /**
+   * 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, controller, correlationId) {
+    this.cancel(key);
+    this.activeRequests.set(key, controller);
+    this.correlationMap.set(key, correlationId);
+  }
+  /**
+   * 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) {
+    this.activeRequests.delete(key);
+    this.correlationMap.delete(key);
+  }
+  /**
+   * 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) {
+    const controller = this.activeRequests.get(key);
+    if (controller) {
+      controller.abort();
+      this.activeRequests.delete(key);
+      this.correlationMap.delete(key);
+    }
+  }
+  /**
+   * 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() {
+    this.activeRequests.forEach((controller) => controller.abort());
+    this.activeRequests.clear();
+    this.correlationMap.clear();
+  }
+  /**
+   * 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) {
+    return this.activeRequests.has(key);
+  }
+  /**
+   * 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) {
+    return this.correlationMap.get(key);
+  }
+};
+
+// src/core/api/Retry/RetryHandler.ts
+var RetryHandler = class {
+  /**
+   * 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');
+   *   }
+   * }
+   * ```
+   */
+  async retryRequest(fn, retries, delay, signal) {
+    try {
+      if (signal?.aborted) {
+        throw new Error(signal.reason || "Request aborted");
+      }
+      return await fn();
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" || signal?.aborted) {
+        throw error;
+      }
+      if (err.type === "validation_error" || err.status === 400) {
+        throw error;
+      }
+      if (retries === 0) throw error;
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(resolve, delay);
+        if (signal) {
+          signal.addEventListener(
+            "abort",
+            () => {
+              clearTimeout(timeoutId);
+              reject(new Error(signal.reason || "Request aborted"));
+            },
+            { once: true }
+          );
+        }
+      });
+      return this.retryRequest(fn, retries - 1, delay * 2, signal);
+    }
+  }
+};
+
+// src/core/api/Signals/SignalManager.ts
+var SignalManager = class {
+  /**
+   * 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) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+      if (signal) {
+        if (signal.aborted) {
+          controller.abort(signal.reason);
+          break;
+        }
+        signal.addEventListener(
+          "abort",
+          () => {
+            controller.abort(signal.reason);
+          },
+          { once: true }
+        );
+      }
+    }
+    return controller;
+  }
+  /**
+   * 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) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort(`Request timeout after ${timeout}ms`);
+    }, timeout);
+    controller.signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeoutId);
+      },
+      { once: true }
+    );
+    return controller;
+  }
+};
+
+// src/core/api/Utils/ResponseParser.ts
+var ResponseParser = class {
+  /**
+   * 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
+   * ```
+   */
+  async parseResponse(response) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    } else if (contentType?.includes("text/")) {
+      return response.text();
+    } else if (contentType?.includes("application/octet-stream")) {
+      return response.blob();
+    } else {
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+  }
+};
+
+// src/core/api/Utils/UrlBuilder.ts
+var UrlBuilder = class {
+  /**
+   * 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, endpoint, params) {
+    const url = new URL(endpoint, baseURL);
+    if (params) {
+      Object.keys(params).forEach((key) => {
+        const value = params[key];
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => url.searchParams.append(key, String(v)));
+          } else {
+            url.searchParams.append(key, String(value));
+          }
+        }
+      });
+    }
+    return url.toString();
+  }
+};
+
+// src/core/api/ApiClient.ts
+var ApiClient = class {
+  baseURL;
+  defaultTimeout;
+  interceptorManager = new InterceptorManager();
+  signalManager = new SignalManager();
+  errorNormalizer = new ErrorNormalizer();
+  responseParser = new ResponseParser();
+  urlBuilder = new UrlBuilder();
+  retryHandler = new RetryHandler();
+  requestManager = new RequestManager();
+  authToken = null;
+  correlationIdPrefix = "api";
+  includeCorrelationId = true;
+  /**
+   * 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 = "", defaultTimeout = 3e4) {
+    this.baseURL = baseURL;
+    this.defaultTimeout = defaultTimeout;
+  }
+  /**
+   * Sets the prefix for auto-generated correlation IDs
+   * @param prefix - The prefix to use for correlation IDs (e.g., 'api', 'web', 'mobile')
+   */
+  setCorrelationIdPrefix(prefix) {
+    this.correlationIdPrefix = prefix;
+  }
+  /**
+   * Enables or disables automatic correlation ID generation
+   * @param include - Whether to include correlation IDs in requests
+   */
+  setIncludeCorrelationId(include) {
+    this.includeCorrelationId = include;
+  }
+  /**
+   * 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) {
+    return this.interceptorManager.addRequestInterceptor(interceptor);
+  }
+  /**
+   * 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) {
+    return this.interceptorManager.addResponseInterceptor(interceptor);
+  }
+  /**
+   * 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) {
+    return this.interceptorManager.addErrorInterceptor(interceptor);
+  }
+  /**
+   * 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) {
+    this.authToken = token;
+  }
+  /**
+   * Retrieves the current authentication token
+   * @returns The current auth token or null if not set
+   */
+  getAuthToken() {
+    return this.authToken;
+  }
+  /**
+   * Cancels a specific request by its key
+   * @param key - The unique key identifying the request to cancel
+   */
+  cancelRequest(key) {
+    this.requestManager.cancel(key);
+  }
+  /**
+   * Cancels all pending requests
+   * Useful for cleanup on navigation or component unmount
+   */
+  cancelAllRequests() {
+    this.requestManager.cancelAll();
+  }
+  /**
+   * 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
+   * });
+   * ```
+   */
+  async request(endpoint, config = {}) {
+    const correlationId = config.correlationId || (!config.skipCorrelationId && this.includeCorrelationId ? generateCorrelationId(this.correlationIdPrefix) : void 0);
+    const requestKey = `${config.method || "GET"}_${endpoint}_${Date.now()}`;
+    const masterController = new AbortController();
+    try {
+      const signals = [
+        config.signal,
+        config.cancelToken?.signal,
+        masterController.signal
+      ];
+      const timeout = config.timeout || this.defaultTimeout;
+      const timeoutController = this.signalManager.createTimeoutSignal(timeout);
+      signals.push(timeoutController.signal);
+      const combinedController = this.signalManager.createCombinedSignal(signals);
+      if (correlationId) {
+        this.requestManager.add(requestKey, masterController, correlationId);
+      }
+      const finalConfig = await this.interceptorManager.applyRequestInterceptors({
+        ...config,
+        signal: combinedController.signal,
+        correlationId
+      });
+      const url = this.urlBuilder.buildURL(
+        this.baseURL,
+        endpoint,
+        finalConfig.params
+      );
+      const headers = new Headers(finalConfig.headers);
+      if (correlationId) {
+        headers.set("X-Correlation-Id", correlationId);
+        headers.set("X-Request-Id", correlationId);
+      }
+      if (this.authToken && !finalConfig.skipAuthRefresh) {
+        headers.set("Authorization", `Bearer ${this.authToken}`);
+      }
+      let fetchBody = finalConfig.body;
+      if (finalConfig.body && typeof finalConfig.body === "object" && !(finalConfig.body instanceof FormData) && !(finalConfig.body instanceof Blob) && !(finalConfig.body instanceof ArrayBuffer) && !(finalConfig.body instanceof URLSearchParams) && !(finalConfig.body instanceof ReadableStream)) {
+        headers.set("Content-Type", "application/json");
+        fetchBody = JSON.stringify(finalConfig.body);
+      }
+      finalConfig.headers = headers;
+      const fetchPromise = async () => {
+        try {
+          const response = await fetch(url, {
+            ...finalConfig,
+            body: fetchBody,
+            signal: combinedController.signal
+          });
+          const responseData = await this.responseParser.parseResponse(response);
+          if (!response.ok) {
+            const errorData = responseData;
+            const error = Object.assign(
+              new Error(
+                errorData.title || `HTTP ${response.status}: ${response.statusText}`
+              ),
+              {
+                type: errorData.type || this.errorNormalizer.getErrorType(response.status),
+                title: errorData.title || this.errorNormalizer.getErrorTitle(response.status),
+                status: response.status,
+                traceId: errorData.traceId || correlationId,
+                errors: errorData.errors,
+                isAborted: false,
+                config: finalConfig
+              }
+            );
+            if (finalConfig.throwErrors !== false) {
+              throw error;
+            } else {
+              return await this.interceptorManager.applyResponseInterceptors({
+                error
+              });
+            }
+          }
+          const apiResponse = {
+            data: responseData
+          };
+          return await this.interceptorManager.applyResponseInterceptors(
+            apiResponse
+          );
+        } catch (error) {
+          if (error.name === "AbortError") {
+            const abortError = Object.assign(
+              new Error(error.message || "Request aborted"),
+              {
+                type: "request_cancelled",
+                title: "Request was cancelled",
+                status: 0,
+                traceId: correlationId,
+                isAborted: true,
+                config: finalConfig
+              }
+            );
+            if (finalConfig.throwErrors !== false) {
+              throw abortError;
+            } else {
+              return await this.interceptorManager.applyResponseInterceptors({
+                error: abortError
+              });
+            }
+          }
+          throw error;
+        }
+      };
+      if (finalConfig.retries && finalConfig.retries > 0) {
+        return await this.retryHandler.retryRequest(
+          fetchPromise,
+          finalConfig.retries,
+          finalConfig.retryDelay || 1e3,
+          combinedController.signal
+        );
+      }
+      return await fetchPromise();
+    } catch (error) {
+      const apiError = this.errorNormalizer.normalizeError(
+        error,
+        config,
+        correlationId
+      );
+      if (config.throwErrors !== false) {
+        await this.interceptorManager.applyErrorInterceptors(apiError);
+        throw apiError;
+      } else {
+        return {
+          error: apiError
+        };
+      }
+    } finally {
+      this.requestManager.remove(requestKey);
+    }
+  }
+  /**
+   * 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(endpoint, config) {
+    return this.request(endpoint, { ...config, method: "GET" });
+  }
+  /**
+   * 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(endpoint, data, config) {
+    return this.request(endpoint, { ...config, method: "POST", body: data });
+  }
+  /**
+   * 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(endpoint, data, config) {
+    return this.request(endpoint, { ...config, method: "PUT", body: data });
+  }
+  /**
+   * 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(endpoint, data, config) {
+    return this.request(endpoint, {
+      ...config,
+      method: "PATCH",
+      body: data
+    });
+  }
+  /**
+   * 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(endpoint, config) {
+    return this.request(endpoint, { ...config, method: "DELETE" });
+  }
+  /**
+   * 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(url, data, config) {
+    const mergedData = { ...data, ...data.filterModel };
+    return this.request(url, {
+      ...config,
+      method: "POST",
+      body: mergedData
+    });
+  }
+};
+
+// src/core/api/createApiClient.ts
+var globalApiClient = null;
+function createApiClient(config = {}) {
+  const {
+    baseURL = "",
+    timeout = 3e4,
+    correlationIdPrefix = "web",
+    includeCorrelationId = true,
+    requestInterceptors = [],
+    responseInterceptors = [],
+    errorInterceptors = []
+  } = config;
+  const client = new ApiClient(baseURL, timeout);
+  client.addRequestInterceptor((config2) => {
+    const token = localStorage.getItem("serviceToken");
+    if (token && !config2.skipAuthRefresh) {
+      config2.headers = {
+        ...config2.headers,
+        Authorization: `Bearer ${token}`
+      };
+    }
+    return config2;
+  });
+  client.setCorrelationIdPrefix(correlationIdPrefix);
+  client.setIncludeCorrelationId(includeCorrelationId);
+  requestInterceptors.forEach((interceptor) => {
+    client.addRequestInterceptor(interceptor);
+  });
+  responseInterceptors.forEach((interceptor) => {
+    client.addResponseInterceptor(interceptor);
+  });
+  errorInterceptors.forEach((interceptor) => {
+    client.addErrorInterceptor(interceptor);
+  });
+  return client;
+}
+function getGlobalApiClient(config) {
+  if (!globalApiClient) {
+    globalApiClient = createApiClient(config);
+  }
+  return globalApiClient;
+}
+function setGlobalApiClient(client) {
+  globalApiClient = client;
+}
+function resetGlobalApiClient() {
+  globalApiClient = null;
+}
+
+// src/core/api/types/CancelToken.ts
+var CancelToken = class _CancelToken {
+  abortController;
+  cancelPromise;
+  cancelResolve;
+  constructor() {
+    this.abortController = new AbortController();
+    this.cancelPromise = new Promise((resolve) => {
+      this.cancelResolve = resolve;
+    });
+  }
+  get signal() {
+    return this.abortController.signal;
+  }
+  cancel(reason) {
+    this.abortController.abort(reason);
+    this.cancelResolve?.();
+  }
+  get isCancelled() {
+    return this.abortController.signal.aborted;
+  }
+  throwIfCancelled() {
+    if (this.isCancelled) {
+      throw new Error("Request cancelled");
+    }
+  }
+  static source() {
+    const token = new _CancelToken();
+    return {
+      token,
+      cancel: (reason) => token.cancel(reason)
+    };
+  }
+};
+
+// src/core/api/useValidationErrors.ts
+import { useCallback } from "react";
+function useValidationErrors(error) {
+  const getFieldError = useCallback(
+    (field) => {
+      if (!error?.errors || !error.errors[field]) return null;
+      const fieldError = error.errors[field];
+      if (typeof fieldError === "string") return fieldError;
+      if (Array.isArray(fieldError)) return fieldError[0];
+      if (typeof fieldError === "object" && "message" in fieldError) {
+        return fieldError.message;
+      }
+      return null;
+    },
+    [error]
+  );
+  const hasFieldError = useCallback(
+    (field) => {
+      return !!getFieldError(field);
+    },
+    [getFieldError]
+  );
+  const getAllErrors = useCallback(() => {
+    if (!error?.errors) return {};
+    const result = {};
+    Object.entries(error.errors).forEach(([key, value]) => {
+      if (typeof value === "string") {
+        result[key] = value;
+      } else if (Array.isArray(value)) {
+        result[key] = value.join(", ");
+      } else if (typeof value === "object" && value && "message" in value) {
+        result[key] = value.message;
+      }
+    });
+    return result;
+  }, [error]);
+  return {
+    getFieldError,
+    hasFieldError,
+    getAllErrors,
+    hasErrors: error?.errors
+  };
+}
+
+// src/core/components/AuthorizedView/AuthorizedView.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+var AuthorizedView = ({ children, show }) => {
+  if (!show) return /* @__PURE__ */ jsx(Fragment, {});
+  return /* @__PURE__ */ jsx(Fragment, { children });
+};
+
+// src/core/components/CancelButton/CancelButton.tsx
+import { Button } from "@mui/material";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var CancelButton = ({
+  children = "Cancel",
+  variant = "outlined",
+  sx,
+  ...rest
+}) => /* @__PURE__ */ jsx2(Button, { variant, sx: { width: "6rem", ...sx }, ...rest, children });
+
+// src/core/components/ClearButton/ClearButton.tsx
+import { Button as Button2 } from "@mui/material";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var ClearButton = ({
+  isSubmitting,
+  handleClear,
+  sx,
+  storeKey
+}) => {
+  const onClick = () => {
+    handleClear();
+    if (storeKey != null) {
+      localStorage.removeItem(storeKey);
+    }
+  };
+  return /* @__PURE__ */ jsx3(
+    Button2,
+    {
+      variant: "outlined",
+      onClick,
+      disabled: isSubmitting,
+      sx,
+      children: "Clear"
+    }
+  );
+};
+
+// src/core/components/Containers/SimpleContainer.tsx
+import { Container } from "@mui/material";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var SimpleContainer = ({
+  children,
+  className,
+  sx
+}) => /* @__PURE__ */ jsx4(Container, { className, sx: { ...sx }, children });
+
+// src/core/components/FilterButton/FilterButton.tsx
+import FilterAltIcon from "@mui/icons-material/FilterAlt";
+import { LoadingButton } from "@mui/lab";
+import { Badge } from "@mui/material";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var FilterButton = ({
+  isSubmitting,
+  show,
+  title,
+  icon,
+  sx,
+  iconSx
+}) => {
+  return /* @__PURE__ */ jsx5(
+    LoadingButton,
+    {
+      type: "submit",
+      variant: "contained",
+      loading: isSubmitting,
+      disabled: !show,
+      disableRipple: true,
+      color: "primary",
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        ...sx
+      },
+      startIcon: /* @__PURE__ */ jsx5(Badge, { color: "error", variant: "standard", children: icon ? icon : /* @__PURE__ */ jsx5(FilterAltIcon, { width: "20", height: "20", sx: iconSx }) }),
+      children: title?.trim() === "" || !title ? "Filter" : title
+    }
+  );
+};
+
+// src/core/components/FilterDisplay/FilterChip.tsx
+import Chip from "@mui/material/Chip";
+import { memo } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var FilterChip = memo(
+  ({
+    fieldKey,
+    filter,
+    onDelete
+  }) => {
+    const hasValue = filter.Value !== null && filter.Value !== void 0 && filter.Value !== "";
+    const label = `${fieldKey.replace("PK", "")}: ${filter.Label}`;
+    return /* @__PURE__ */ jsx6(
+      Chip,
+      {
+        label,
+        variant: hasValue ? "filled" : "outlined",
+        size: "small",
+        onDelete: hasValue ? onDelete : void 0
+      },
+      fieldKey
+    );
+  }
+);
+FilterChip.displayName = "FilterChip";
+
+// src/core/components/FilterDisplay/FilterDisplay.tsx
+import { Card, CardContent, Typography, Box } from "@mui/material";
+import { memo as memo2, useMemo } from "react";
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var ProgramsFilterDisplay = memo2(
+  (props) => {
+    const { friendlyFilter, onFriendlyFilterChange } = props;
+    const deleteHandlers = useMemo(() => {
+      if (!onFriendlyFilterChange) return {};
+      const handlers = {};
+      for (const key of Object.keys(friendlyFilter)) {
+        handlers[key] = () => onFriendlyFilterChange(key);
+      }
+      return handlers;
+    }, [onFriendlyFilterChange, friendlyFilter]);
+    const chipList = useMemo(() => {
+      return Object.entries(friendlyFilter).map(([key, filter]) => /* @__PURE__ */ jsx7(
+        FilterChip,
+        {
+          fieldKey: key,
+          filter,
+          onDelete: deleteHandlers[key]
+        },
+        key
+      ));
+    }, [friendlyFilter, deleteHandlers]);
+    return /* @__PURE__ */ jsx7(Card, { sx: { mb: 2 }, children: /* @__PURE__ */ jsxs(CardContent, { children: [
+      /* @__PURE__ */ jsx7(Typography, { variant: "h6", gutterBottom: true, children: "Active Filters" }),
+      /* @__PURE__ */ jsx7(Box, { display: "flex", gap: 1, flexWrap: "wrap", children: chipList })
+    ] }) });
+  }
+);
+ProgramsFilterDisplay.displayName = "FilterDisplay";
+
+// src/core/components/FilterWrapper/FilterWrapper.tsx
+import ManageSearchIcon from "@mui/icons-material/ManageSearch";
+import {
+  Box as Box2,
+  Card as Card2,
+  CardContent as CardContent2,
+  CardHeader,
+  Divider,
+  Grid,
+  Typography as Typography2,
+  useTheme
+} from "@mui/material";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs2 } from "react/jsx-runtime";
+var FilterWrapper = ({
+  children,
+  title,
+  filterCount,
+  cardSx,
+  textSx,
+  icon,
+  iconSx,
+  showCount
+}) => {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs2(
+    Card2,
+    {
+      sx: {
+        position: "relative",
+        borderRadius: "0px",
+        mb: 2,
+        ...cardSx
+      },
+      children: [
+        /* @__PURE__ */ jsx8(
+          CardHeader,
+          {
+            sx: {
+              display: "flex",
+              flexWrap: "wrap",
+              p: "1rem",
+              ".MuiCardHeader-action": {
+                margin: 0,
+                alignSelf: "center"
+              },
+              alignItems: "center"
+            },
+            title: /* @__PURE__ */ jsxs2(Box2, { sx: { display: "flex", alignItems: "center", gap: 0.5 }, children: [
+              icon ? icon : /* @__PURE__ */ jsx8(
+                ManageSearchIcon,
+                {
+                  sx: {
+                    height: "2.5rem",
+                    color: theme.palette.primary.main,
+                    ...iconSx
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsxs2(
+                Typography2,
+                {
+                  variant: "h5",
+                  sx: {
+                    fontWeight: "bold",
+                    color: theme.palette.primary.main,
+                    ...textSx
+                  },
+                  children: [
+                    title ? title : "Filter",
+                    " ",
+                    showCount ? `(${filterCount ? filterCount : 0})` : /* @__PURE__ */ jsx8(Fragment2, {})
+                  ]
+                }
+              )
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx8(Divider, {}),
+        /* @__PURE__ */ jsx8(CardContent2, { sx: { py: 2 }, children: /* @__PURE__ */ jsx8(Grid, { container: true, spacing: 2, children }) })
+      ]
+    }
+  );
+};
+
+// src/core/components/Footer/Footer.tsx
+import { Box as Box3, Typography as Typography3 } from "@mui/material";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var Footer = () => {
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  return /* @__PURE__ */ jsx9(
+    Box3,
+    {
+      component: "footer",
+      sx: {
+        py: 2,
+        px: 4,
+        mt: "auto",
+        backgroundColor: (theme) => theme.palette.mode === "light" ? theme.palette.grey[200] : theme.palette.grey[800]
+      },
+      children: /* @__PURE__ */ jsx9(Typography3, { variant: "body2", color: "text.secondary", align: "center", children: `\xA9 Copyright ${currentYear} GN. All rights reserved by Parul University.` })
+    }
+  );
+};
+
+// src/core/components/LabelText/LabelText.tsx
+import { Grid as Grid2, Tooltip, Typography as Typography4 } from "@mui/material";
+import { jsx as jsx10, jsxs as jsxs3 } from "react/jsx-runtime";
+var LabelText = ({
+  label,
+  value,
+  gridSize,
+  containerSize,
+  labelSx,
+  valueSx
+}) => {
+  const defaultGridSize = {
+    labelSize: { xs: 6, sm: 6, md: 6 },
+    valueSize: { xs: 12, sm: 6, md: 6 }
+  };
+  const defaultContainerSize = { xs: 12, sm: 6, md: 6 };
+  const size = gridSize || defaultGridSize;
+  const container = containerSize || defaultContainerSize;
+  return /* @__PURE__ */ jsxs3(
+    Grid2,
+    {
+      size: container,
+      sx: {
+        display: "flex",
+        flexDirection: { xs: "column", sm: "row", md: "row" },
+        "&:hover": { bgcolor: "#efefef", overflow: "hidden" }
+      },
+      children: [
+        /* @__PURE__ */ jsxs3(
+          Grid2,
+          {
+            size: size.labelSize,
+            sx: {
+              padding: "5px",
+              fontSize: "14px",
+              textAlign: { xs: "left", sm: "right", md: "right" },
+              ...labelSx
+            },
+            children: [
+              label,
+              " :"
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx10(
+          Grid2,
+          {
+            size: size.valueSize,
+            sx: { padding: "5px", display: "flex", flexWrap: "wrap" },
+            children: /* @__PURE__ */ jsx10(Tooltip, { title: value, arrow: true, children: /* @__PURE__ */ jsx10(
+              Typography4,
+              {
+                sx: {
+                  fontSize: "14px",
+                  wordBreak: "break-word",
+                  overflow: "hidden",
+                  display: "-webkit-box",
+                  textOverflow: "ellipsis",
+                  WebkitLineClamp: 2,
+                  WebkitBoxOrient: "vertical",
+                  ...valueSx,
+                  color: "#078dee"
+                },
+                children: value ? value : "-"
+              }
+            ) })
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/core/components/RenderIf/RenderIf.tsx
+import { Fragment as Fragment3, jsx as jsx11 } from "react/jsx-runtime";
+var RenderIf = ({
+  show,
+  children
+}) => {
+  return show ? /* @__PURE__ */ jsx11(Fragment3, { children }) : null;
+};
+
+// src/core/components/SectionBox/SectionBox.tsx
+import { Box as Box4, Divider as Divider2, Grid as Grid3, Stack, Typography as Typography5 } from "@mui/material";
+import { memo as memo3, useMemo as useMemo2 } from "react";
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs4 } from "react/jsx-runtime";
+var getSectionTheme = (variant = "default") => {
+  const themes = {
+    default: {
+      bgcolor: "#faebd7",
+      color: "#925d21"
+    },
+    form: {
+      bgcolor: "#cdced1",
+      color: "black"
+    },
+    info: {
+      bgcolor: "#e3f2fd",
+      color: "#1976d2"
+    },
+    warning: {
+      bgcolor: "#fff3e0",
+      color: "#f57c00"
+    },
+    error: {
+      bgcolor: "#ffebee",
+      color: "#d32f2f"
+    }
+  };
+  return themes[variant];
+};
+var SectionBox = memo3(
+  ({
+    title,
+    children,
+    spacing = 0,
+    containerSx,
+    titleSx,
+    variant = "default",
+    icon,
+    actions
+  }) => {
+    const themeColors = useMemo2(() => getSectionTheme(variant), [variant]);
+    const headerSx = useMemo2(
+      () => ({
+        px: 1.5,
+        py: 0.1,
+        width: "fit-content",
+        ...themeColors,
+        ...titleSx
+      }),
+      [themeColors, titleSx]
+    );
+    const contentSx = useMemo2(
+      () => ({
+        padding: "16px",
+        ...containerSx
+      }),
+      [containerSx]
+    );
+    return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+      /* @__PURE__ */ jsxs4(Box4, { sx: { display: "flex", flexDirection: "column", width: "100%" }, children: [
+        /* @__PURE__ */ jsxs4(
+          Stack,
+          {
+            direction: "row",
+            justifyContent: "space-between",
+            alignItems: "center",
+            sx: headerSx,
+            children: [
+              /* @__PURE__ */ jsxs4(Stack, { direction: "row", alignItems: "center", spacing: 1, children: [
+                icon,
+                /* @__PURE__ */ jsx12(Typography5, { sx: { fontSize: "15px", fontWeight: 400 }, children: title })
+              ] }),
+              actions
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx12(Divider2, {})
+      ] }),
+      /* @__PURE__ */ jsx12(Grid3, { container: true, spacing, sx: contentSx, children })
+    ] });
+  }
+);
+
+// src/core/components/SimpleTabs/SimpleTabs.tsx
+import { TabContext } from "@mui/lab";
+import { Box as Box5, Tab, Tabs } from "@mui/material";
+import { useState } from "react";
+import { jsx as jsx13, jsxs as jsxs5 } from "react/jsx-runtime";
+var SimpleTabs = ({
+  tabs,
+  defaultValue = 1,
+  onTabChange,
+  children,
+  tabSx,
+  tabsSx
+}) => {
+  const [value, setValue] = useState(defaultValue);
+  const handleChange = (event, newValue) => {
+    setValue(newValue);
+    if (onTabChange) onTabChange(newValue);
+  };
+  return /* @__PURE__ */ jsxs5(TabContext, { value, children: [
+    /* @__PURE__ */ jsx13(Box5, { sx: { borderBottom: 1, borderColor: "divider", width: "100%" }, children: /* @__PURE__ */ jsx13(
+      Tabs,
+      {
+        value,
+        onChange: handleChange,
+        sx: { px: 2, py: 0, ...tabsSx },
+        children: tabs.map((tab) => /* @__PURE__ */ jsx13(
+          Tab,
+          {
+            label: tab.label,
+            value: tab.value,
+            disabled: tab.permission === false,
+            sx: { fontSize: "1rem", ...tabSx }
+          },
+          tab.value
+        ))
+      }
+    ) }),
+    children
+  ] });
+};
+
+// src/core/components/SubmitButton/SubmitButton.tsx
+import { LoadingButton as LoadingButton2 } from "@mui/lab";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var SubmitButton = ({
+  loading = false,
+  ...rest
+}) => /* @__PURE__ */ jsx14(
+  LoadingButton2,
+  {
+    loading,
+    variant: "contained",
+    color: "primary",
+    type: "submit",
+    ...rest,
+    sx: { fontWeight: 400 },
+    children: "Submit"
+  }
+);
+
+// src/core/components/WithRef/WithRef.tsx
+import { forwardRef } from "react";
+function withDataModal(component) {
+  return forwardRef(
+    (props, ref) => component({ ...props, ref })
+  );
+}
+
+// src/core/config.ts
+var Config = {
+  defaultPageSize: 20,
+  apiBaseUrl: "http://localhost:5143"
+  // apiBaseUrl: 'http://192.168.1.246:5143',
+};
+var dateTimePatterns = {
+  dateTime: "DD MMM YYYY h:mm A",
+  // 17 Apr 2022 12:00 am
+  date: "DD MMM YYYY",
+  // 17 Apr 2022
+  month_year_short_format: "MMM YYYY",
+  month_year_full_format: "MMMM YYYY",
+  year: "YYYY",
+  time: "h:mm a",
+  // 12:00 am
+  split: {
+    dateTime: "DD/MM/YYYY h:mm A",
+    // 17/04/2022 12:00 am
+    date: "DD/MM/YYYY"
+    // 17/04/2022
+  },
+  paramCase: {
+    dateTime: "DD-MM-YYYY h:mm A",
+    // 17-04-2022 12:00 am
+    date: "DD-MM-YYYY",
+    // 17-04-2022
+    dateReverse: "YYYY-MM-DD",
+    // 2022-04-17 for compare date
+    MonthYear: "MMM-YYYY"
+  }
+};
+
+// src/core/hooks/useApiClient.ts
+import { useMemo as useMemo3 } from "react";
+function useApiClient(config = {}) {
+  return useMemo3(
+    () => createApiClient(config),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      config.baseURL,
+      config.timeout,
+      config.correlationIdPrefix,
+      config.includeCorrelationId,
+      config.authToken,
+      config.requestInterceptors,
+      config.responseInterceptors,
+      config.errorInterceptors
+    ]
+  );
+}
+
+// src/core/hooks/useFormErrorHandler.ts
+import { useCallback as useCallback2 } from "react";
+import { toast } from "sonner";
+var useFormErrorHandler = ({
+  setError,
+  successMessage = {
+    create: "Created successfully",
+    update: "Updated successfully"
+  },
+  errorMessage = {
+    noChanges: "No changes were made",
+    general: "Failed to save. Please try again."
+  }
+}) => {
+  const getFieldError = useCallback2(
+    (fields, fieldName) => {
+      if (!fields || !fields[fieldName]) return void 0;
+      const fieldError = fields[fieldName];
+      if (typeof fieldError === "string") {
+        return fieldError;
+      }
+      if (Array.isArray(fieldError)) {
+        return fieldError.join(", ");
+      }
+      if (typeof fieldError === "object" && "message" in fieldError) {
+        return fieldError.message;
+      }
+      return void 0;
+    },
+    []
+  );
+  const handleSuccess = useCallback2(
+    (isEditing, rowsAffected) => {
+      if (rowsAffected !== void 0 && rowsAffected > 0) {
+        toast.success(
+          isEditing ? successMessage.update : successMessage.create
+        );
+        return true;
+      } else if (rowsAffected === 0) {
+        toast.error(errorMessage.noChanges);
+        return false;
+      }
+      toast.success(isEditing ? successMessage.update : successMessage.create);
+      return true;
+    },
+    [successMessage, errorMessage]
+  );
+  const handleError = useCallback2(
+    (processedError) => {
+      if (processedError.type === "validation_error" && processedError.errors && setError) {
+        Object.keys(processedError.errors).forEach((fieldName) => {
+          const fieldError = getFieldError(processedError.errors, fieldName);
+          if (fieldError) {
+            setError(fieldName, {
+              type: "server",
+              message: fieldError
+            });
+          }
+        });
+        toast.error(
+          processedError.title || "Please check the form for validation errors"
+        );
+      } else {
+        toast.error(processedError.title || errorMessage.general);
+      }
+    },
+    [errorMessage.general, getFieldError, setError]
+  );
+  return {
+    handleSuccess,
+    handleError
+  };
+};
+var useDeleteHandler = ({
+  successMessage = "Deleted successfully",
+  errorMessage = "Failed to delete. Please try again."
+} = {}) => {
+  return useFormErrorHandler({
+    successMessage: {
+      create: successMessage,
+      // Not used for delete, but required for type
+      update: successMessage
+    },
+    errorMessage: {
+      noChanges: "No changes were made",
+      // Not typically used for delete
+      general: errorMessage
+    }
+    // setError is omitted (undefined) for delete operations
+  });
+};
+
+// src/core/utils/CacheUtility/index.ts
+import { useQueryClient } from "@tanstack/react-query";
+import { useMemo as useMemo4 } from "react";
+var CacheUtility = class {
+  constructor(queryClient) {
+    this.queryClient = queryClient;
+  }
+  /**
+   * Get cached data using only the queryKey from query factory
+   */
+  getCachedData(queryKey) {
+    return this.queryClient.getQueryData(queryKey);
+  }
+  /**
+   * Get cached data with transformation using select function
+   */
+  getCachedDataWithSelect(queryKey, select) {
+    const cachedData = this.queryClient.getQueryData(queryKey);
+    if (cachedData === void 0) {
+      return void 0;
+    }
+    return select(cachedData);
+  }
+};
+function useCacheUtility() {
+  const queryClient = useQueryClient();
+  return useMemo4(() => new CacheUtility(queryClient), [queryClient]);
+}
+
+// src/core/utils/watch/core.ts
+import { useWatch } from "react-hook-form";
+var useWatchForm = (control) => useWatch({ control });
+var useWatchField = (control, name) => useWatch({ control, name });
+var useWatchFields = (control, names) => useWatch({ control, name: names });
+
+// src/core/utils/watch/utilities.ts
+import { useEffect, useMemo as useMemo5, useState as useState2 } from "react";
+import { useWatch as useWatch2 } from "react-hook-form";
+var useWatchTransform = (control, name, transform) => {
+  const value = useWatch2({ control, name });
+  return useMemo5(() => transform(value), [value, transform]);
+};
+var useWatchDefault = (control, name, defaultValue) => {
+  const value = useWatch2({ control, name });
+  return value ?? defaultValue;
+};
+var useWatchBoolean = (control, name, defaultValue = false) => {
+  const value = useWatch2({ control, name });
+  return Boolean(value ?? defaultValue);
+};
+var useWatchBatch = (control, fields) => {
+  const values = useWatch2({ control, name: fields });
+  return useMemo5(() => {
+    const result = {};
+    fields.forEach((field, index) => {
+      result[field] = values[index];
+    });
+    return result;
+  }, [values, fields]);
+};
+var useWatchConditional = (control, name, shouldWatch, fallback) => {
+  const activeValue = useWatch2({
+    control,
+    name,
+    disabled: !shouldWatch
+  });
+  return shouldWatch ? activeValue : fallback;
+};
+var useWatchDebounced = (control, name, delay = 300) => {
+  const value = useWatch2({ control, name });
+  const [debouncedValue, setDebouncedValue] = useState2(value);
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+};
+var useWatchSelector = (control, name, selector, deps = []) => {
+  const value = useWatch2({ control, name });
+  return useMemo5(
+    () => selector(value),
+    [value, selector, ...deps]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+};
+
+// src/core/utils/watch/index.ts
+var typedWatch = {
+  // === CORE FUNCTIONS ===
+  /** Watch entire form */
+  form: useWatchForm,
+  /** Watch single field */
+  field: useWatchField,
+  /** Watch multiple fields */
+  fields: useWatchFields,
+  // === UTILITY FUNCTIONS ===
+  /** Watch with transformation */
+  transform: useWatchTransform,
+  /** Watch with default value */
+  withDefault: useWatchDefault,
+  /** Watch as boolean */
+  boolean: useWatchBoolean,
+  /** Watch multiple with custom keys */
+  batch: useWatchBatch,
+  /** Watch conditionally */
+  conditional: useWatchConditional,
+  /** Watch with debouncing */
+  debounced: useWatchDebounced,
+  /** Watch with selector */
+  selector: useWatchSelector
+};
+
+// src/core/utils/calculateFilterCount.ts
+var calculateFilterCount = (model) => Object.values(model).filter(
+  (v) => v !== null && v !== void 0 && String(v).trim() !== ""
+).length;
+
+// src/core/utils/format-time.ts
+import dayjs from "dayjs";
+import duration from "dayjs/plugin/duration";
+import relativeTime from "dayjs/plugin/relativeTime";
+dayjs.extend(duration);
+dayjs.extend(relativeTime);
+var formatPatterns = {
+  dateTime: "DD MMM YYYY h:mm A",
+  // 17 Apr 2022 12:00 am
+  date: "DD MMM YYYY",
+  // 17 Apr 2022
+  month_year_short_format: "MMM YYYY",
+  month_year_full_format: "MMMM YYYY",
+  year: "YYYY",
+  time: "h:mm a",
+  // 12:00 am
+  split: {
+    dateTime: "DD/MM/YYYY h:mm A",
+    // 17/04/2022 12:00 am
+    date: "DD/MM/YYYY"
+    // 17/04/2022
+  },
+  paramCase: {
+    dateTime: "DD-MM-YYYY h:mm A",
+    // 17-04-2022 12:00 am
+    date: "DD-MM-YYYY",
+    // 17-04-2022
+    dateReverse: "YYYY-MM-DD",
+    // 2022-04-17 for compare date
+    MonthYear: "MMM-YYYY"
+  }
+};
+var isValidDate = (date) => date !== null && date !== void 0 && dayjs(date).isValid();
+function today(template) {
+  return dayjs(/* @__PURE__ */ new Date()).startOf("day").format(template);
+}
+function fDateTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).format(template ?? formatPatterns.dateTime);
+}
+function fDate(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).format(template ?? formatPatterns.date);
+}
+function fTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).format(template ?? formatPatterns.time);
+}
+function fTimestamp(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).valueOf();
+}
+function fToNow(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return dayjs(date).toNow(true);
+}
+function fIsBetween(inputDate, startDate, endDate) {
+  if (!isValidDate(inputDate) || !isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  const formattedInputDate = fTimestamp(inputDate);
+  const formattedStartDate = fTimestamp(startDate);
+  const formattedEndDate = fTimestamp(endDate);
+  if (formattedInputDate === "Invalid date" || formattedStartDate === "Invalid date" || formattedEndDate === "Invalid date") {
+    return false;
+  }
+  return formattedInputDate >= formattedStartDate && formattedInputDate <= formattedEndDate;
+}
+function fIsAfter(startDate, endDate) {
+  if (!isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  return dayjs(startDate).isAfter(endDate);
+}
+function fIsSame(startDate, endDate, unitToCompare) {
+  if (!isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  return dayjs(startDate).isSame(endDate, unitToCompare ?? "year");
+}
+function fDateRangeShortLabel(startDate, endDate, initial) {
+  if (!isValidDate(startDate) || !isValidDate(endDate) || fIsAfter(startDate, endDate)) {
+    return "Invalid date";
+  }
+  let label = `${fDate(startDate)} - ${fDate(endDate)}`;
+  if (initial) {
+    return label;
+  }
+  const isSameYear = fIsSame(startDate, endDate, "year");
+  const isSameMonth = fIsSame(startDate, endDate, "month");
+  const isSameDay = fIsSame(startDate, endDate, "day");
+  if (isSameYear && !isSameMonth) {
+    label = `${fDate(startDate, "DD MMM")} - ${fDate(endDate)}`;
+  } else if (isSameYear && isSameMonth && !isSameDay) {
+    label = `${fDate(startDate, "DD")} - ${fDate(endDate)}`;
+  } else if (isSameYear && isSameMonth && isSameDay) {
+    label = `${fDate(endDate)}`;
+  }
+  return label;
+}
+function fAdd({
+  years = 0,
+  months = 0,
+  days = 0,
+  hours = 0,
+  minutes = 0,
+  seconds = 0,
+  milliseconds = 0
+}) {
+  const result = dayjs().add(
+    dayjs.duration({
+      years,
+      months,
+      days,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    })
+  ).format();
+  return result;
+}
+function fSub({
+  years = 0,
+  months = 0,
+  days = 0,
+  hours = 0,
+  minutes = 0,
+  seconds = 0,
+  milliseconds = 0
+}) {
+  const result = dayjs().subtract(
+    dayjs.duration({
+      years,
+      months,
+      days,
+      hours,
+      minutes,
+      seconds,
+      milliseconds
+    })
+  ).format();
+  return result;
+}
+
+// src/core/utils/getEmptyObject.ts
+function getEmptyObject(data, defaultValues = {}) {
+  const obj = {};
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    const type = typeof value;
+    if (type === "number") {
+      obj[key] = 0;
+    } else if (type === "string" || type === "boolean") {
+      obj[key] = null;
+    } else if (value instanceof Date) {
+      obj[key] = null;
+    } else {
+      obj[key] = null;
+    }
+  }
+  return { ...obj, ...defaultValues };
+}
+
+// src/core/utils/useStableRowCount.ts
+import { useRef, useMemo as useMemo6 } from "react";
+function useStableRowCount(currentTotal) {
+  const rowCountRef = useRef(currentTotal || 0);
+  const stableRowCount = useMemo6(() => {
+    if (currentTotal !== void 0) {
+      rowCountRef.current = currentTotal;
+    }
+    return rowCountRef.current;
+  }, [currentTotal]);
+  return stableRowCount;
+}
+
+export {
+  generateCorrelationId,
+  RequestManager,
+  ApiClient,
+  createApiClient,
+  getGlobalApiClient,
+  setGlobalApiClient,
+  resetGlobalApiClient,
+  CancelToken,
+  useValidationErrors,
+  AuthorizedView,
+  CancelButton,
+  ClearButton,
+  SimpleContainer,
+  FilterButton,
+  FilterChip,
+  ProgramsFilterDisplay,
+  FilterWrapper,
+  Footer,
+  LabelText,
+  RenderIf,
+  SectionBox,
+  SimpleTabs,
+  SubmitButton,
+  withDataModal,
+  Config,
+  dateTimePatterns,
+  useApiClient,
+  useFormErrorHandler,
+  useDeleteHandler,
+  CacheUtility,
+  useCacheUtility,
+  useWatchForm,
+  useWatchField,
+  useWatchFields,
+  useWatchTransform,
+  useWatchDefault,
+  useWatchBoolean,
+  useWatchBatch,
+  useWatchConditional,
+  useWatchDebounced,
+  useWatchSelector,
+  typedWatch,
+  calculateFilterCount,
+  formatPatterns,
+  today,
+  fDateTime,
+  fDate,
+  fTime,
+  fTimestamp,
+  fToNow,
+  fIsBetween,
+  fIsAfter,
+  fIsSame,
+  fDateRangeShortLabel,
+  fAdd,
+  fSub,
+  getEmptyObject,
+  useStableRowCount
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/core/api/CorrelationIdGenerator.ts", "../src/core/api/Errors/ErrorNormalizer.ts", "../src/core/api/Interceptors/InterceptorManager.ts", "../src/core/api/RequestManager.ts", "../src/core/api/Retry/RetryHandler.ts", "../src/core/api/Signals/SignalManager.ts", "../src/core/api/Utils/ResponseParser.ts", "../src/core/api/Utils/UrlBuilder.ts", "../src/core/api/ApiClient.ts", "../src/core/api/createApiClient.ts", "../src/core/api/types/CancelToken.ts", "../src/core/api/useValidationErrors.ts", "../src/core/components/AuthorizedView/AuthorizedView.tsx", "../src/core/components/CancelButton/CancelButton.tsx", "../src/core/components/ClearButton/ClearButton.tsx", "../src/core/components/Containers/SimpleContainer.tsx", "../src/core/components/FilterButton/FilterButton.tsx", "../src/core/components/FilterDisplay/FilterChip.tsx", "../src/core/components/FilterDisplay/FilterDisplay.tsx", "../src/core/components/FilterWrapper/FilterWrapper.tsx", "../src/core/components/Footer/Footer.tsx", "../src/core/components/LabelText/LabelText.tsx", "../src/core/components/RenderIf/RenderIf.tsx", "../src/core/components/SectionBox/SectionBox.tsx", "../src/core/components/SimpleTabs/SimpleTabs.tsx", "../src/core/components/SubmitButton/SubmitButton.tsx", "../src/core/components/WithRef/WithRef.tsx", "../src/core/config.ts", "../src/core/hooks/useApiClient.ts", "../src/core/hooks/useFormErrorHandler.ts", "../src/core/utils/CacheUtility/index.ts", "../src/core/utils/watch/core.ts", "../src/core/utils/watch/utilities.ts", "../src/core/utils/watch/index.ts", "../src/core/utils/calculateFilterCount.ts", "../src/core/utils/format-time.ts", "../src/core/utils/getEmptyObject.ts", "../src/core/utils/useStableRowCount.ts"],
  "sourcesContent": ["/**\r\n * @fileoverview Utilities for generating correlation IDs for distributed request tracing.\r\n *\r\n * Correlation IDs are unique identifiers attached to each API request to enable\r\n * tracking and debugging across distributed systems, microservices, and log aggregation.\r\n *\r\n * @module CorrelationIdGenerator\r\n */\r\n\r\n/**\r\n * Generates a cryptographically random UUID v4 string.\r\n *\r\n * Prefers native `crypto.randomUUID()` when available (modern browsers and Node.js 19+),\r\n * falling back to a compliant UUID v4 implementation using `Math.random()`.\r\n *\r\n * @internal This function is not exported from the public API\r\n * @returns A UUID v4 string in the format `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`\r\n *\r\n * @example\r\n * ```typescript\r\n * const uuid = generateUUID();\r\n * // => \"a1b2c3d4-e5f6-4789-a012-b3c4d5e6f7a8\"\r\n * ```\r\n */\r\nfunction generateUUID(): string {\r\n  if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n    return crypto.randomUUID();\r\n  }\r\n\r\n  // Fallback UUID v4 generator\r\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\r\n    const r = (Math.random() * 16) | 0;\r\n    const v = c === 'x' ? r : (r & 0x3) | 0x8;\r\n\r\n    return v.toString(16);\r\n  });\r\n}\r\n\r\n/**\r\n * Generates a unique correlation ID for API request tracking and distributed tracing.\r\n *\r\n * Correlation IDs help track requests across multiple services and systems. They are\r\n * automatically attached to outgoing requests via HTTP headers (`X-Correlation-Id` and\r\n * `X-Request-Id`) and can be used to:\r\n * - Correlate logs across distributed systems\r\n * - Track request flows in microservices architectures\r\n * - Debug issues by tracing a specific request's journey\r\n * - Monitor performance across service boundaries\r\n *\r\n * The generated ID follows the format: `{prefix}-{uuid}` or just `{uuid}` if no prefix is provided.\r\n *\r\n * @param prefix - Optional prefix to namespace correlation IDs by context (e.g., 'api', 'web', 'mobile')\r\n * @returns A correlation ID string, optionally prefixed\r\n * @public\r\n *\r\n * @example\r\n * Basic usage:\r\n * ```typescript\r\n * const id = generateCorrelationId();\r\n * // => \"a1b2c3d4-e5f6-4789-a012-b3c4d5e6f7a8\"\r\n * ```\r\n *\r\n * @example\r\n * With prefix for context identification:\r\n * ```typescript\r\n * const webId = generateCorrelationId('web');\r\n * // => \"web-a1b2c3d4-e5f6-4789-a012-b3c4d5e6f7a8\"\r\n *\r\n * const apiId = generateCorrelationId('api');\r\n * // => \"api-f1e2d3c4-b5a6-4987-a012-b3c4d5e6f7a8\"\r\n * ```\r\n *\r\n * @example\r\n * Configuring in ApiClient:\r\n * ```typescript\r\n * const client = new ApiClient('https://api.example.com');\r\n * client.setCorrelationIdPrefix('mobile');\r\n * // All requests will have correlation IDs like \"mobile-{uuid}\"\r\n * ```\r\n */\r\nexport function generateCorrelationId(prefix?: string): string {\r\n  const uuid = generateUUID();\r\n\r\n  return prefix ? `${prefix}-${uuid}` : uuid;\r\n}\r\n", "import type { ApiError, ApiErrorType } from '../types/ApiError';\r\nimport type { RequestConfig } from '../types/RequestConfig';\r\n\r\n/**\r\n * Normalizes various error types into a consistent, structured ApiError format.\r\n *\r\n * This internal class handles the complex task of converting any type of error\r\n * (network errors, HTTP errors, abort errors, timeouts, etc.) into a standardized\r\n * {@link ApiError} structure with proper categorization and metadata.\r\n *\r\n * Key Features:\r\n * - **Error Categorization**: Classifies errors by type (validation, client, server, network, etc.)\r\n * - **HTTP Status Mapping**: Converts status codes to human-readable titles\r\n * - **Correlation ID Tracking**: Preserves or injects correlation IDs for tracing\r\n * - **Abort Detection**: Identifies and properly handles request cancellations\r\n * - **Consistent Structure**: Ensures all errors conform to the ApiError interface\r\n *\r\n * @internal This class is not exported from the public API\r\n */\r\nexport class ErrorNormalizer {\r\n  /**\r\n   * Maps an HTTP status code to a standardized error type category.\r\n   *\r\n   * This categorization helps consumers handle different error classes appropriately:\r\n   * - `validation_error` (400): Client sent invalid data\r\n   * - `client_error` (401-499): Client-side issues (auth, permissions, not found, etc.)\r\n   * - `server_error` (500-599): Server-side failures\r\n   * - `unknown_error`: Unrecognized status codes\r\n   *\r\n   * @param status - HTTP status code from the response\r\n   * @returns The error type category as a string\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * normalizer.getErrorType(400); // => 'validation_error'\r\n   * normalizer.getErrorType(404); // => 'client_error'\r\n   * normalizer.getErrorType(500); // => 'server_error'\r\n   * normalizer.getErrorType(0);   // => 'unknown_error'\r\n   * ```\r\n   */\r\n  getErrorType(status: number): ApiErrorType {\r\n    if (status >= 400 && status < 500) {\r\n      return status === 400 ? 'validation_error' : 'client_error';\r\n    } else if (status >= 500) {\r\n      return 'server_error';\r\n    }\r\n\r\n    return 'unknown_error';\r\n  }\r\n\r\n  /**\r\n   * Maps an HTTP status code to a human-readable error title.\r\n   *\r\n   * Provides user-friendly error messages for common HTTP status codes.\r\n   * Falls back to a generic \"HTTP Error {status}\" format for unmapped codes.\r\n   *\r\n   * @param status - HTTP status code from the response\r\n   * @returns A human-readable error title\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * normalizer.getErrorTitle(404); // => 'Not Found'\r\n   * normalizer.getErrorTitle(500); // => 'Internal Server Error'\r\n   * normalizer.getErrorTitle(999); // => 'HTTP Error 999'\r\n   * ```\r\n   */\r\n  getErrorTitle(status: number): string {\r\n    const titles: Record<number, string> = {\r\n      400: 'Bad Request',\r\n      401: 'Unauthorized',\r\n      403: 'Forbidden',\r\n      404: 'Not Found',\r\n      405: 'Method Not Allowed',\r\n      408: 'Request Timeout',\r\n      409: 'Conflict',\r\n      422: 'Unprocessable Entity',\r\n      429: 'Too Many Requests',\r\n      500: 'Internal Server Error',\r\n      502: 'Bad Gateway',\r\n      503: 'Service Unavailable',\r\n      504: 'Gateway Timeout',\r\n    };\r\n\r\n    return titles[status] || `HTTP Error ${status}`;\r\n  }\r\n\r\n  /**\r\n   * Normalizes any error into a consistent, structured ApiError format.\r\n   *\r\n   * This method handles various error scenarios and ensures they all conform to\r\n   * the {@link ApiError} interface with appropriate categorization and metadata:\r\n   *\r\n   * - **Existing ApiErrors**: Enhances with missing fields (traceId, config)\r\n   * - **AbortErrors**: Marks as `request_cancelled` with isAborted flag\r\n   * - **Timeout Errors**: Categorizes as `timeout_error` with 408 status\r\n   * - **Network Errors**: Categorizes as `network_error` with 0 status\r\n   * - **Unknown Errors**: Fallback category for unexpected error types\r\n   *\r\n   * All normalized errors include:\r\n   * - `type`: Error category for programmatic handling\r\n   * - `title`: Human-readable error title\r\n   * - `status`: HTTP status code (or 0 for non-HTTP errors)\r\n   * - `traceId`: Correlation ID for distributed tracing\r\n   * - `isAborted`: Boolean flag indicating if request was cancelled\r\n   * - `config`: Original request configuration for debugging\r\n   *\r\n   * @param error - The error to normalize (can be any type)\r\n   * @param config - The request configuration that led to this error\r\n   * @param correlationId - Optional correlation ID for tracing\r\n   * @returns A fully structured ApiError instance\r\n   *\r\n   * @example\r\n   * Normalizing a fetch AbortError:\r\n   * ```typescript\r\n   * try {\r\n   *   await fetch(url, { signal });\r\n   * } catch (error) {\r\n   *   const apiError = normalizer.normalizeError(error, config, 'req-123');\r\n   *   // apiError.type === 'request_cancelled'\r\n   *   // apiError.isAborted === true\r\n   * }\r\n   * ```\r\n   *\r\n   * @example\r\n   * Normalizing a timeout:\r\n   * ```typescript\r\n   * const timeoutError = new Error('Request timeout after 30000ms');\r\n   * const apiError = normalizer.normalizeError(timeoutError, config);\r\n   * // apiError.type === 'timeout_error'\r\n   * // apiError.status === 408\r\n   * ```\r\n   */\r\n  normalizeError(\r\n    error: unknown,\r\n    config: RequestConfig,\r\n    correlationId?: string\r\n  ): ApiError {\r\n    // Handle primitive errors (strings, numbers, etc.)\r\n    if (error === null || error === undefined) {\r\n      return Object.assign(new Error('An unknown error occurred'), {\r\n        type: 'unknown_error',\r\n        title: 'Unknown Error',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: false,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    // Handle string errors\r\n    if (typeof error === 'string') {\r\n      return Object.assign(new Error(error), {\r\n        type: 'unknown_error',\r\n        title: 'Unknown Error',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: false,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    const err = error as Partial<ApiError> & { message?: string; name?: string };\r\n\r\n    // If error already has ApiError structure, enhance it\r\n    if (err.type || err.title || err.errors) {\r\n      return Object.assign(\r\n        error instanceof Error ? error : new Error(err.message ?? 'Unknown error'),\r\n        {\r\n          type: err.type,\r\n          title: err.title,\r\n          status: err.status,\r\n          traceId: err.traceId || correlationId,\r\n          errors: err.errors,\r\n          isAborted: err.isAborted || false,\r\n          config,\r\n        }\r\n      );\r\n    }\r\n\r\n    if (err.name === 'AbortError' || err.isAborted) {\r\n      return Object.assign(new Error(err.message ?? 'Request was aborted'), {\r\n        type: 'request_cancelled',\r\n        title: 'Request was cancelled',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: true,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    if (err.message?.includes('timeout')) {\r\n      return Object.assign(new Error(err.message), {\r\n        type: 'timeout_error',\r\n        title: 'Request Timeout',\r\n        status: 408,\r\n        traceId: correlationId,\r\n        isAborted: true,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    if (err.message?.includes('network')) {\r\n      return Object.assign(new Error(err.message ?? 'Network request failed'), {\r\n        type: 'network_error',\r\n        title: 'Network Error',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: false,\r\n        config,\r\n      } as ApiError);\r\n    }\r\n\r\n    return Object.assign(\r\n      new Error(err.message ?? 'An unknown error occurred'),\r\n      {\r\n        type: 'unknown_error',\r\n        title: 'Unknown Error',\r\n        status: 0,\r\n        traceId: correlationId,\r\n        isAborted: false,\r\n        config,\r\n      } as ApiError\r\n    );\r\n  }\r\n}\r\n", "import type { ApiError } from '../types/ApiError';\r\nimport type { ErrorInterceptor } from '../types/ErrorInterceptor';\r\nimport type { RequestConfig } from '../types/RequestConfig';\r\nimport type { RequestInterceptor } from '../types/RequestInterceptor';\r\nimport type { ResponseInterceptor } from '../types/ResponseInterceptor';\r\n\r\nimport type { ApiResponse } from '@/types';\r\n\r\n/**\r\n * Manages the registration and execution of request/response/error interceptors.\r\n *\r\n * This internal class implements the interceptor pattern, allowing middleware-style\r\n * functions to be registered and executed at different points in the request lifecycle:\r\n * - **Request Interceptors**: Modify requests before they are sent\r\n * - **Response Interceptors**: Transform responses before they are returned\r\n * - **Error Interceptors**: Handle or transform errors before they are thrown\r\n *\r\n * Interceptors are executed sequentially in the order they were registered,\r\n * forming a processing pipeline. Each interceptor can:\r\n * - Inspect the data passing through\r\n * - Transform or enhance the data\r\n * - Short-circuit the pipeline (for errors)\r\n * - Perform side effects (logging, monitoring, etc.)\r\n *\r\n * Key Features:\r\n * - **Sequential Execution**: Interceptors run in registration order\r\n * - **Unregistration Support**: Returns cleanup function for each interceptor\r\n * - **Type Safety**: Fully typed interceptor functions with generics\r\n * - **Error Handling**: Graceful handling of interceptor failures\r\n *\r\n * @internal This class is not exported from the public API\r\n *\r\n * @example\r\n * Common interceptor patterns:\r\n * ```typescript\r\n * const manager = new InterceptorManager();\r\n *\r\n * // Request logging\r\n * manager.addRequestInterceptor(async (config) => {\r\n *   console.log('Request:', config.method, config.url);\r\n *   return config;\r\n * });\r\n *\r\n * // Response transformation\r\n * manager.addResponseInterceptor(async (response) => {\r\n *   if (response.apiData) {\r\n *     response.apiData = camelCaseKeys(response.apiData);\r\n *   }\r\n *   return response;\r\n * });\r\n *\r\n * // Error monitoring\r\n * manager.addErrorInterceptor(async (error) => {\r\n *   if (error.status >= 500) {\r\n *     await logToMonitoring(error);\r\n *   }\r\n *   throw error; // Re-throw to maintain error flow\r\n * });\r\n * ```\r\n */\r\nexport class InterceptorManager {\r\n  /**\r\n   * Array of registered request interceptors\r\n   * @private\r\n   */\r\n  private readonly requestInterceptors: RequestInterceptor[] = [];\r\n\r\n  /**\r\n   * Array of registered response interceptors\r\n   * @private\r\n   */\r\n  private readonly responseInterceptors: ResponseInterceptor[] = [];\r\n\r\n  /**\r\n   * Array of registered error interceptors\r\n   * @private\r\n   */\r\n  private readonly errorInterceptors: ErrorInterceptor[] = [];\r\n\r\n  /**\r\n   * Registers a request interceptor to modify requests before they are sent.\r\n   *\r\n   * Request interceptors can:\r\n   * - Add or modify headers\r\n   * - Transform request bodies\r\n   * - Add query parameters\r\n   * - Implement request signing\r\n   * - Log outgoing requests\r\n   *\r\n   * @param interceptor - Async function that receives and returns RequestConfig\r\n   * @returns Cleanup function to unregister this interceptor\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Add authentication header\r\n   * const unregister = manager.addRequestInterceptor(async (config) => {\r\n   *   const token = await getAuthToken();\r\n   *   config.headers = config.headers || new Headers();\r\n   *   config.headers.set('Authorization', `Bearer ${token}`);\r\n   *   return config;\r\n   * });\r\n   *\r\n   * // Later, remove the interceptor\r\n   * unregister();\r\n   * ```\r\n   */\r\n  addRequestInterceptor(interceptor: RequestInterceptor): () => void {\r\n    this.requestInterceptors.push(interceptor);\r\n\r\n    return () => {\r\n      const index = this.requestInterceptors.indexOf(interceptor);\r\n\r\n      if (index > -1) this.requestInterceptors.splice(index, 1);\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Registers a response interceptor to transform responses before they are returned.\r\n   *\r\n   * Response interceptors can:\r\n   * - Transform response data format\r\n   * - Extract nested data structures\r\n   * - Add computed properties\r\n   * - Cache responses\r\n   * - Log successful responses\r\n   *\r\n   * @param interceptor - Async function that receives and returns ApiResponse\r\n   * @returns Cleanup function to unregister this interceptor\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Extract data from envelope\r\n   * manager.addResponseInterceptor(async (response) => {\r\n   *   if (response.apiData?.result) {\r\n   *     response.apiData = response.apiData.result;\r\n   *   }\r\n   *   return response;\r\n   * });\r\n   *\r\n   * // Add timestamps\r\n   * manager.addResponseInterceptor(async (response) => {\r\n   *   return {\r\n   *     ...response,\r\n   *     receivedAt: new Date().toISOString()\r\n   *   };\r\n   * });\r\n   * ```\r\n   */\r\n  addResponseInterceptor(interceptor: ResponseInterceptor): () => void {\r\n    this.responseInterceptors.push(interceptor);\r\n\r\n    return () => {\r\n      const index = this.responseInterceptors.indexOf(interceptor);\r\n\r\n      if (index > -1) this.responseInterceptors.splice(index, 1);\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Registers an error interceptor to handle or transform errors before they are thrown.\r\n   *\r\n   * Error interceptors can:\r\n   * - Log errors to monitoring services\r\n   * - Transform error formats\r\n   * - Implement retry logic\r\n   * - Show user notifications\r\n   * - Extract validation errors\r\n   *\r\n   * **Note:** Error interceptors should re-throw the error (or a transformed version)\r\n   * to maintain the error flow. The final error is always thrown.\r\n   *\r\n   * @param interceptor - Async function that receives and returns (or throws) ApiError\r\n   * @returns Cleanup function to unregister this interceptor\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Log to monitoring service\r\n   * manager.addErrorInterceptor(async (error) => {\r\n   *   if (error.status >= 500) {\r\n   *     await Sentry.captureException(error, {\r\n   *       extra: { traceId: error.traceId }\r\n   *     });\r\n   *   }\r\n   *   throw error; // Re-throw to continue error flow\r\n   * });\r\n   *\r\n   * // Transform error messages\r\n   * manager.addErrorInterceptor(async (error) => {\r\n   *   if (error.status === 404) {\r\n   *     error.title = 'Resource not found';\r\n   *   }\r\n   *   throw error;\r\n   * });\r\n   * ```\r\n   */\r\n  addErrorInterceptor(interceptor: ErrorInterceptor): () => void {\r\n    this.errorInterceptors.push(interceptor);\r\n\r\n    return () => {\r\n      const index = this.errorInterceptors.indexOf(interceptor);\r\n\r\n      if (index > -1) this.errorInterceptors.splice(index, 1);\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Applies all registered request interceptors in sequential order.\r\n   *\r\n   * Each interceptor receives the config modified by the previous interceptor,\r\n   * forming a processing pipeline. If any interceptor throws an error,\r\n   * the pipeline stops and the error propagates.\r\n   *\r\n   * @param config - The initial request configuration\r\n   * @returns The modified request configuration after all interceptors\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const config = { method: 'GET', url: '/users' };\r\n   * const finalConfig = await manager.applyRequestInterceptors(config);\r\n   * // finalConfig has been processed by all registered interceptors\r\n   * ```\r\n   */\r\n  async applyRequestInterceptors(\r\n    config: RequestConfig\r\n  ): Promise<RequestConfig> {\r\n    let modifiedConfig = { ...config };\r\n\r\n    for (const interceptor of this.requestInterceptors) {\r\n      modifiedConfig = await interceptor(modifiedConfig);\r\n    }\r\n\r\n    return modifiedConfig;\r\n  }\r\n\r\n  /**\r\n   * Applies all registered response interceptors in sequential order.\r\n   *\r\n   * Each interceptor receives the response modified by the previous interceptor,\r\n   * forming a processing pipeline. If any interceptor throws an error,\r\n   * the pipeline stops and the error propagates.\r\n   *\r\n   * @template T - The type of the response data\r\n   * @param response - The initial API response\r\n   * @returns The modified response after all interceptors\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const response = { data: { id: 1, name: 'John' } };\r\n   * const finalResponse = await manager.applyResponseInterceptors(response);\r\n   * // finalResponse has been processed by all registered interceptors\r\n   * ```\r\n   */\r\n  async applyResponseInterceptors<T>(\r\n    response: ApiResponse<T>\r\n  ): Promise<ApiResponse<T>> {\r\n    let modifiedResponse = response;\r\n\r\n    for (const interceptor of this.responseInterceptors) {\r\n      modifiedResponse = await interceptor(modifiedResponse);\r\n    }\r\n\r\n    return modifiedResponse;\r\n  }\r\n\r\n  /**\r\n   * Applies all registered error interceptors in sequential order and re-throws.\r\n   *\r\n   * Each interceptor receives the error (potentially modified by previous interceptors).\r\n   * Interceptors can transform the error before re-throwing it. The final error\r\n   * is always thrown to maintain error flow.\r\n   *\r\n   * If an interceptor itself throws an error, that becomes the new error to process\r\n   * by subsequent interceptors.\r\n   *\r\n   * @param error - The initial API error\r\n   * @returns Never returns (always throws)\r\n   * @throws The final error after all interceptors have processed it\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * try {\r\n   *   await manager.applyErrorInterceptors(error);\r\n   * } catch (finalError) {\r\n   *   // finalError has been processed by all registered error interceptors\r\n   * }\r\n   * ```\r\n   */\r\n  async applyErrorInterceptors(error: ApiError): Promise<never> {\r\n    let modifiedError = error;\r\n\r\n    for (const interceptor of this.errorInterceptors) {\r\n      try {\r\n        modifiedError = await interceptor(modifiedError);\r\n      } catch (e) {\r\n        modifiedError = e as ApiError;\r\n      }\r\n    }\r\n\r\n    throw modifiedError;\r\n  }\r\n}\r\n", "/**\r\n * Manages active HTTP requests with support for cancellation and correlation tracking.\r\n *\r\n * This internal class maintains a registry of in-flight requests, allowing them to be\r\n * cancelled individually or in bulk. Each request is tracked by a unique key and\r\n * associated with a correlation ID for distributed tracing.\r\n *\r\n * Key Features:\r\n * - **Request Deduplication**: Automatically cancels duplicate requests with the same key\r\n * - **Correlation Tracking**: Maps request keys to correlation IDs for tracing\r\n * - **Bulk Cancellation**: Cancel all pending requests at once (useful for cleanup)\r\n * - **Memory Management**: Automatically cleans up tracking data when requests complete\r\n *\r\n * @internal This class is not exported from the public API\r\n *\r\n * @example\r\n * ```typescript\r\n * const manager = new RequestManager();\r\n * const controller = new AbortController();\r\n *\r\n * // Track a request\r\n * manager.add('GET_/users/123', controller, 'api-abc123');\r\n *\r\n * // Cancel specific request\r\n * manager.cancel('GET_/users/123');\r\n *\r\n * // Or cancel all requests\r\n * manager.cancelAll();\r\n * ```\r\n */\r\nexport class RequestManager {\r\n  /**\r\n   * Map of active request keys to their abort controllers\r\n   * @private\r\n   */\r\n  private activeRequests: Map<string, AbortController> = new Map();\r\n\r\n  /**\r\n   * Map of request keys to their correlation IDs for tracing\r\n   * @private\r\n   */\r\n  private correlationMap: Map<string, string> = new Map();\r\n\r\n  /**\r\n   * Registers a new request for tracking and cancellation management.\r\n   *\r\n   * If a request with the same key already exists, it will be automatically\r\n   * cancelled before the new one is registered (request deduplication).\r\n   *\r\n   * @param key - Unique identifier for the request (typically method + URL + timestamp)\r\n   * @param controller - AbortController for cancelling the request\r\n   * @param correlationId - Correlation ID for distributed tracing\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const controller = new AbortController();\r\n   * manager.add('GET_/api/users_1699999999', controller, 'api-abc123');\r\n   * ```\r\n   */\r\n  add(key: string, controller: AbortController, correlationId: string): void {\r\n    // Cancel existing request with same key if exists\r\n    this.cancel(key);\r\n    this.activeRequests.set(key, controller);\r\n    this.correlationMap.set(key, correlationId);\r\n  }\r\n\r\n  /**\r\n   * Removes a request from tracking without cancelling it.\r\n   *\r\n   * This is typically called when a request completes successfully or fails.\r\n   * Use {@link cancel} instead if you need to abort the request.\r\n   *\r\n   * @param key - Unique identifier for the request to remove\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Called automatically after request completes\r\n   * manager.remove('GET_/api/users_1699999999');\r\n   * ```\r\n   */\r\n  remove(key: string): void {\r\n    this.activeRequests.delete(key);\r\n    this.correlationMap.delete(key);\r\n  }\r\n\r\n  /**\r\n   * Cancels a specific request and removes it from tracking.\r\n   *\r\n   * If the request doesn't exist or was already cancelled, this operation is a no-op.\r\n   * The associated AbortController's signal will be triggered, causing any active\r\n   * fetch operations to abort.\r\n   *\r\n   * @param key - Unique identifier for the request to cancel\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // User navigates away, cancel the pending request\r\n   * manager.cancel('GET_/api/users_1699999999');\r\n   * ```\r\n   */\r\n  cancel(key: string): void {\r\n    const controller = this.activeRequests.get(key);\r\n\r\n    if (controller) {\r\n      controller.abort();\r\n      this.activeRequests.delete(key);\r\n      this.correlationMap.delete(key);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Cancels all active requests and clears all tracking data.\r\n   *\r\n   * This is useful for cleanup scenarios such as:\r\n   * - User logout\r\n   * - Component unmount\r\n   * - Navigation to a different part of the application\r\n   * - Error recovery that requires a clean slate\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Cancel all pending requests on logout\r\n   * function handleLogout() {\r\n   *   apiClient.cancelAllRequests();\r\n   *   // ... rest of logout logic\r\n   * }\r\n   * ```\r\n   */\r\n  cancelAll(): void {\r\n    this.activeRequests.forEach(controller => controller.abort());\r\n    this.activeRequests.clear();\r\n    this.correlationMap.clear();\r\n  }\r\n\r\n  /**\r\n   * Checks if a request with the given key is currently being tracked.\r\n   *\r\n   * @param key - Unique identifier for the request\r\n   * @returns `true` if the request is active, `false` otherwise\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * if (manager.has('GET_/api/users_1699999999')) {\r\n   *   console.log('Request is still pending');\r\n   * }\r\n   * ```\r\n   */\r\n  has(key: string): boolean {\r\n    return this.activeRequests.has(key);\r\n  }\r\n\r\n  /**\r\n   * Retrieves the correlation ID for a given request key.\r\n   *\r\n   * Correlation IDs are used for distributed tracing and request tracking\r\n   * across services and logs.\r\n   *\r\n   * @param key - Unique identifier for the request\r\n   * @returns The correlation ID if found, `undefined` otherwise\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const correlationId = manager.getCorrelationId('GET_/api/users_1699999999');\r\n   * if (correlationId) {\r\n   *   console.log('Trace request with ID:', correlationId);\r\n   * }\r\n   * ```\r\n   */\r\n  getCorrelationId(key: string): string | undefined {\r\n    return this.correlationMap.get(key);\r\n  }\r\n}\r\n", "import type { ApiError } from '../types/ApiError';\r\n\r\n/**\r\n * Implements automatic retry logic with exponential backoff for failed HTTP requests.\r\n *\r\n * This internal class handles transient failures by automatically retrying requests\r\n * with progressively increasing delays between attempts. The exponential backoff\r\n * strategy helps prevent overwhelming a struggling server while giving temporary\r\n * issues time to resolve.\r\n *\r\n * Key Features:\r\n * - **Exponential Backoff**: Doubles delay between retries (e.g., 1s, 2s, 4s, 8s)\r\n * - **Smart Error Detection**: Skips retry for non-retryable errors (validation, aborts)\r\n * - **Abort Support**: Respects cancellation signals during retry delays\r\n * - **Type Safety**: Fully generic implementation preserving return types\r\n *\r\n * Retry Strategy:\r\n * - **Retryable**: Network errors, 5xx server errors, timeouts\r\n * - **Non-Retryable**: Validation errors (400), AbortErrors, cancelled requests\r\n *\r\n * @internal This class is not exported from the public API\r\n *\r\n * @example\r\n * Retry configuration in ApiClient:\r\n * ```typescript\r\n * const client = new ApiClient('https://api.example.com');\r\n *\r\n * // Retry up to 3 times with 1s initial delay\r\n * const { apiData } = await client.get('/users', {\r\n *   retries: 3,\r\n *   retryDelay: 1000  // 1s, 2s, 4s\r\n * });\r\n * ```\r\n */\r\nexport class RetryHandler {\r\n  /**\r\n   * Retries a failed request with exponential backoff strategy.\r\n   *\r\n   * The retry logic works as follows:\r\n   * 1. Attempts the request immediately\r\n   * 2. On failure, checks if the error is retryable\r\n   * 3. If retryable and retries remain, waits for the current delay\r\n   * 4. Doubles the delay for the next attempt\r\n   * 5. Repeats until success or retries exhausted\r\n   *\r\n   * **Non-Retryable Errors:**\r\n   * - Validation errors (400) - Client sent bad data\r\n   * - AbortErrors - Request was explicitly cancelled\r\n   * - Requests with aborted signals\r\n   *\r\n   * **Abort Handling:**\r\n   * If the signal is aborted during a retry delay, the retry is immediately\r\n   * cancelled and an AbortError is thrown.\r\n   *\r\n   * @template T - The return type of the function being retried\r\n   * @param fn - Async function to retry on failure\r\n   * @param retries - Number of retry attempts remaining (decrements each retry)\r\n   * @param delay - Current delay in milliseconds before next retry\r\n   * @param signal - Optional AbortSignal to cancel retries\r\n   * @returns Promise resolving to the function's result on success\r\n   * @throws The last error encountered if all retries are exhausted\r\n   * @throws AbortError if the signal is aborted during execution or delay\r\n   *\r\n   * @example\r\n   * Basic retry usage:\r\n   * ```typescript\r\n   * const handler = new RetryHandler();\r\n   * const fetchUser = () => fetch('/api/users/123').then(r => r.json());\r\n   *\r\n   * try {\r\n   *   const user = await handler.retryRequest(\r\n   *     fetchUser,\r\n   *     3,      // 3 retries\r\n   *     1000    // Start with 1s delay\r\n   *   );\r\n   *   console.log('User:', user);\r\n   * } catch (error) {\r\n   *   console.error('Failed after all retries:', error);\r\n   * }\r\n   * ```\r\n   *\r\n   * @example\r\n   * With cancellation support:\r\n   * ```typescript\r\n   * const controller = new AbortController();\r\n   * const signal = controller.signal;\r\n   *\r\n   * // Cancel after 5 seconds\r\n   * setTimeout(() => controller.abort(), 5000);\r\n   *\r\n   * try {\r\n   *   await handler.retryRequest(fetchUser, 5, 1000, signal);\r\n   * } catch (error) {\r\n   *   if (error.name === 'AbortError') {\r\n   *     console.log('Retry cancelled');\r\n   *   }\r\n   * }\r\n   * ```\r\n   */\r\n  async retryRequest<T>(\r\n    fn: () => Promise<T>,\r\n    retries: number,\r\n    delay: number,\r\n    signal?: AbortSignal\r\n  ): Promise<T> {\r\n    try {\r\n      // Check if already aborted\r\n      if (signal?.aborted) {\r\n        throw new Error(signal.reason || 'Request aborted');\r\n      }\r\n\r\n      return await fn();\r\n    } catch (error: unknown) {\r\n      const err = error as ApiError;\r\n\r\n      // Don't retry if aborted\r\n      if (err.name === 'AbortError' || signal?.aborted) {\r\n        throw error;\r\n      }\r\n\r\n      // Don't retry validation errors\r\n      if (err.type === 'validation_error' || err.status === 400) {\r\n        throw error;\r\n      }\r\n\r\n      if (retries === 0) throw error;\r\n\r\n      // Wait with abort support\r\n      await new Promise<void>((resolve, reject) => {\r\n        const timeoutId = setTimeout(resolve, delay);\r\n\r\n        if (signal) {\r\n          signal.addEventListener(\r\n            'abort',\r\n            () => {\r\n              clearTimeout(timeoutId);\r\n              reject(new Error(signal.reason || 'Request aborted'));\r\n            },\r\n            { once: true }\r\n          );\r\n        }\r\n      });\r\n\r\n      return this.retryRequest(fn, retries - 1, delay * 2, signal);\r\n    }\r\n  }\r\n}\r\n", "/**\r\n * Manages AbortSignal creation and composition for request cancellation and timeouts.\r\n *\r\n * This internal class provides utilities for working with the AbortSignal API,\r\n * enabling sophisticated cancellation patterns by combining multiple cancellation\r\n * sources and creating timeout-based signals.\r\n *\r\n * Key Features:\r\n * - **Signal Composition**: Combine multiple AbortSignals into one\r\n * - **Timeout Signals**: Create signals that auto-abort after a delay\r\n * - **Early Abort Detection**: Immediately abort if any source is already aborted\r\n * - **Resource Cleanup**: Automatic timeout cleanup on abort\r\n *\r\n * Use Cases:\r\n * - Combine user cancellation + timeout + component unmount signals\r\n * - Create request deadlines\r\n * - Implement cascading cancellation\r\n *\r\n * @internal This class is not exported from the public API\r\n *\r\n * @example\r\n * Combining multiple cancellation sources:\r\n * ```typescript\r\n * const manager = new SignalManager();\r\n * const userCancel = new AbortController();\r\n * const unmountSignal = componentUnmountSignal;\r\n *\r\n * // Request will be cancelled if either user clicks cancel OR component unmounts\r\n * const combined = manager.createCombinedSignal([\r\n *   userCancel.signal,\r\n *   unmountSignal\r\n * ]);\r\n *\r\n * fetch('/api/data', { signal: combined.signal });\r\n * ```\r\n */\r\nexport class SignalManager {\r\n  /**\r\n   * Creates a combined AbortController that aborts when any source signal aborts.\r\n   *\r\n   * This method implements the \"any\" pattern for cancellation: the combined signal\r\n   * will abort as soon as ANY of the source signals abort. This is useful for\r\n   * coordinating multiple cancellation conditions:\r\n   * - User clicks cancel button\r\n   * - Request timeout expires\r\n   * - Component unmounts\r\n   * - Parent request is cancelled\r\n   *\r\n   * **Early Abort Optimization:**\r\n   * If any source signal is already aborted when this method is called,\r\n   * the returned controller is immediately aborted without setting up listeners.\r\n   *\r\n   * **Memory Management:**\r\n   * Event listeners are registered with `{ once: true }` to prevent memory leaks,\r\n   * as they automatically clean up after firing.\r\n   *\r\n   * @param signals - Array of AbortSignals to combine (undefined values are ignored)\r\n   * @returns A new AbortController that aborts when any source signal aborts\r\n   *\r\n   * @example\r\n   * User cancellation + timeout:\r\n   * ```typescript\r\n   * const userController = new AbortController();\r\n   * const timeout = manager.createTimeoutSignal(30000);\r\n   *\r\n   * const combined = manager.createCombinedSignal([\r\n   *   userController.signal,\r\n   *   timeout.signal\r\n   * ]);\r\n   *\r\n   * // Request will be cancelled after 30s OR when user clicks cancel\r\n   * fetch('/api/data', { signal: combined.signal });\r\n   * ```\r\n   *\r\n   * @example\r\n   * React component with cleanup:\r\n   * ```typescript\r\n   * useEffect(() => {\r\n   *   const controller = new AbortController();\r\n   *\r\n   *   const combined = manager.createCombinedSignal([\r\n   *     controller.signal,\r\n   *     unmountSignal  // From component lifecycle\r\n   *   ]);\r\n   *\r\n   *   fetchData(combined.signal);\r\n   *\r\n   *   return () => controller.abort(); // Cleanup\r\n   * }, []);\r\n   * ```\r\n   */\r\n  createCombinedSignal(\r\n    signals: Array<AbortSignal | undefined>\r\n  ): AbortController {\r\n    const controller = new AbortController();\r\n\r\n    for (const signal of signals) {\r\n      if (signal) {\r\n        if (signal.aborted) {\r\n          controller.abort(signal.reason);\r\n          break;\r\n        }\r\n\r\n        signal.addEventListener(\r\n          'abort',\r\n          () => {\r\n            controller.abort(signal.reason);\r\n          },\r\n          { once: true }\r\n        );\r\n      }\r\n    }\r\n\r\n    return controller;\r\n  }\r\n\r\n  /**\r\n   * Creates an AbortController that automatically aborts after a specified timeout.\r\n   *\r\n   * This method creates a time-based cancellation mechanism useful for implementing\r\n   * request timeouts and deadlines. The signal will automatically abort after the\r\n   * specified duration, providing a consistent timeout experience.\r\n   *\r\n   * **Automatic Cleanup:**\r\n   * If the signal is aborted by other means before the timeout expires, the internal\r\n   * setTimeout is automatically cleared to prevent memory leaks.\r\n   *\r\n   * **Abort Reason:**\r\n   * The abort reason includes the timeout duration for debugging purposes:\r\n   * `\"Request timeout after {timeout}ms\"`\r\n   *\r\n   * @param timeout - Timeout duration in milliseconds\r\n   * @returns An AbortController that will abort after the timeout\r\n   *\r\n   * @example\r\n   * Simple request timeout:\r\n   * ```typescript\r\n   * const manager = new SignalManager();\r\n   * const timeout = manager.createTimeoutSignal(5000); // 5 seconds\r\n   *\r\n   * try {\r\n   *   const response = await fetch('/api/slow-endpoint', {\r\n   *     signal: timeout.signal\r\n   *   });\r\n   *   const data = await response.json();\r\n   * } catch (error) {\r\n   *   if (error.name === 'AbortError') {\r\n   *     console.error('Request timed out after 5 seconds');\r\n   *   }\r\n   * }\r\n   * ```\r\n   *\r\n   * @example\r\n   * Different timeouts for different operations:\r\n   * ```typescript\r\n   * // Short timeout for quick operations\r\n   * const quickTimeout = manager.createTimeoutSignal(2000);\r\n   * await fetch('/api/health', { signal: quickTimeout.signal });\r\n   *\r\n   * // Long timeout for heavy operations\r\n   * const longTimeout = manager.createTimeoutSignal(60000);\r\n   * await fetch('/api/export', { signal: longTimeout.signal });\r\n   * ```\r\n   *\r\n   * @example\r\n   * Manual cancellation before timeout:\r\n   * ```typescript\r\n   * const timeout = manager.createTimeoutSignal(30000);\r\n   *\r\n   * // If user cancels, timeout is automatically cleaned up\r\n   * timeout.abort('User cancelled');\r\n   * // Internal setTimeout is cleared, no memory leak\r\n   * ```\r\n   */\r\n  createTimeoutSignal(timeout: number): AbortController {\r\n    const controller = new AbortController();\r\n\r\n    const timeoutId = setTimeout(() => {\r\n      controller.abort(`Request timeout after ${timeout}ms`);\r\n    }, timeout);\r\n\r\n    // Clean up timeout when signal is aborted\r\n    controller.signal.addEventListener(\r\n      'abort',\r\n      () => {\r\n        clearTimeout(timeoutId);\r\n      },\r\n      { once: true }\r\n    );\r\n\r\n    return controller;\r\n  }\r\n}\r\n", "import type { ResponseData } from '../Models';\r\n\r\n/**\r\n * Parses HTTP response bodies into appropriate JavaScript types based on Content-Type headers.\r\n *\r\n * This internal class handles the complexity of converting various HTTP response formats\r\n * into usable JavaScript data structures. It intelligently detects the response type\r\n * and applies the appropriate parsing strategy.\r\n *\r\n * Supported Content Types:\r\n * - **application/json**: Parsed as JSON objects/arrays\r\n * - **text/*** (text/plain, text/html, etc.): Returned as string\r\n * - **application/octet-stream**: Returned as Blob for binary data\r\n * - **Unknown/Missing**: Attempts JSON parse, falls back to text\r\n *\r\n * Key Features:\r\n * - **Automatic Detection**: Uses Content-Type header to determine parsing strategy\r\n * - **Graceful Fallback**: Attempts JSON parsing for unknown types, falls back to text\r\n * - **Binary Support**: Handles binary data via Blob\r\n * - **Type Safety**: Returns typed ResponseData union\r\n *\r\n * @internal This class is not exported from the public API\r\n *\r\n * @example\r\n * Parsing different response types:\r\n * ```typescript\r\n * const parser = new ResponseParser();\r\n *\r\n * // JSON response\r\n * const jsonResponse = new Response('{\"id\": 1}', {\r\n *   headers: { 'Content-Type': 'application/json' }\r\n * });\r\n * const data = await parser.parseResponse(jsonResponse);\r\n * // => { id: 1 }\r\n *\r\n * // Text response\r\n * const textResponse = new Response('Hello World', {\r\n *   headers: { 'Content-Type': 'text/plain' }\r\n * });\r\n * const text = await parser.parseResponse(textResponse);\r\n * // => \"Hello World\"\r\n *\r\n * // Binary response\r\n * const blobResponse = new Response(binaryData, {\r\n *   headers: { 'Content-Type': 'application/octet-stream' }\r\n * });\r\n * const blob = await parser.parseResponse(blobResponse);\r\n * // => Blob { ... }\r\n * ```\r\n */\r\nexport class ResponseParser {\r\n  /**\r\n   * Parses the HTTP response body into an appropriate JavaScript type.\r\n   *\r\n   * The parsing strategy is determined by the Content-Type header:\r\n   * 1. **JSON** (application/json): Calls `response.json()`\r\n   * 2. **Text** (text/*): Calls `response.text()`\r\n   * 3. **Binary** (application/octet-stream): Calls `response.blob()`\r\n   * 4. **Unknown**: Reads as text, attempts JSON parse, falls back to raw text\r\n   *\r\n   * **Fallback Behavior:**\r\n   * For responses without a Content-Type header or with unknown types, the parser\r\n   * attempts to parse as JSON first (common for APIs that don't set proper headers).\r\n   * If JSON parsing fails, it returns the raw text.\r\n   *\r\n   * @param response - The Fetch API Response object to parse\r\n   * @returns Promise resolving to the parsed response data\r\n   * @returns Can be: JSON object/array, string, or Blob depending on Content-Type\r\n   *\r\n   * @example\r\n   * API response parsing:\r\n   * ```typescript\r\n   * const response = await fetch('/api/users');\r\n   * const data = await parser.parseResponse(response);\r\n   *\r\n   * if (typeof data === 'string') {\r\n   *   console.log('Text response:', data);\r\n   * } else if (data instanceof Blob) {\r\n   *   console.log('Binary response:', data.size, 'bytes');\r\n   * } else {\r\n   *   console.log('JSON response:', data);\r\n   * }\r\n   * ```\r\n   *\r\n   * @example\r\n   * Handling different content types:\r\n   * ```typescript\r\n   * // CSV file download\r\n   * const csvResponse = await fetch('/api/export.csv');\r\n   * const blob = await parser.parseResponse(csvResponse);\r\n   * // Returns Blob for download\r\n   *\r\n   * // JSON API\r\n   * const jsonResponse = await fetch('/api/users');\r\n   * const users = await parser.parseResponse(jsonResponse);\r\n   * // Returns parsed JSON array\r\n   *\r\n   * // Plain text logs\r\n   * const logResponse = await fetch('/api/logs');\r\n   * const logs = await parser.parseResponse(logResponse);\r\n   * // Returns string\r\n   * ```\r\n   */\r\n  async parseResponse(response: Response): Promise<ResponseData> {\r\n    const contentType = response.headers.get('content-type');\r\n\r\n    if (contentType?.includes('application/json')) {\r\n      return response.json();\r\n    } else if (contentType?.includes('text/')) {\r\n      return response.text();\r\n    } else if (contentType?.includes('application/octet-stream')) {\r\n      return response.blob();\r\n    } else {\r\n      // Try JSON first, fallback to text\r\n      const text = await response.text();\r\n\r\n      try {\r\n        return JSON.parse(text) as Record<string, unknown>;\r\n      } catch {\r\n        return text;\r\n      }\r\n    }\r\n  }\r\n}\r\n", "import type { QueryParams } from '../Models';\r\n\r\n/**\r\n * Constructs fully-qualified URLs with proper query parameter encoding.\r\n *\r\n * This internal class handles the complexity of URL construction, combining\r\n * base URLs, endpoints, and query parameters with proper encoding and array\r\n * handling. It uses the native URL API for reliable URL composition.\r\n *\r\n * Key Features:\r\n * - **URL Composition**: Safely combines base URL and endpoint paths\r\n * - **Query Parameter Encoding**: Automatic encoding of special characters\r\n * - **Array Support**: Handles array parameters with multiple values\r\n * - **Null/Undefined Filtering**: Automatically skips null/undefined values\r\n * - **Type Safety**: Strongly typed query parameter values\r\n *\r\n * Array Handling:\r\n * Array parameters are serialized by appending the same key multiple times:\r\n * `?tags=javascript&tags=typescript&tags=react`\r\n *\r\n * @internal This class is not exported from the public API\r\n *\r\n * @example\r\n * Building URLs with query parameters:\r\n * ```typescript\r\n * const builder = new UrlBuilder();\r\n *\r\n * const url = builder.buildURL(\r\n *   'https://api.example.com',\r\n *   '/users',\r\n *   { active: true, role: 'admin', page: 1 }\r\n * );\r\n * // => \"https://api.example.com/users?active=true&role=admin&page=1\"\r\n * ```\r\n */\r\nexport class UrlBuilder {\r\n  /**\r\n   * Builds a complete URL by combining base URL, endpoint, and query parameters.\r\n   *\r\n   * The URL construction process:\r\n   * 1. Combines `baseURL` and `endpoint` using URL API\r\n   * 2. Iterates through query parameters\r\n   * 3. Skips null/undefined values\r\n   * 4. Handles arrays by appending multiple values with same key\r\n   * 5. Converts all values to strings\r\n   * 6. Returns fully-qualified URL string\r\n   *\r\n   * **Path Handling:**\r\n   * The endpoint can be either relative or absolute:\r\n   * - Relative: `/users` \u2192 Combined with baseURL\r\n   * - Absolute: `https://other-api.com/users` \u2192 Uses absolute URL\r\n   *\r\n   * **Encoding:**\r\n   * All parameter values are automatically URL-encoded by the URL API,\r\n   * so special characters (spaces, &, =, etc.) are safely handled.\r\n   *\r\n   * @param baseURL - Base URL for the API (e.g., 'https://api.example.com')\r\n   * @param endpoint - API endpoint path relative to baseURL (e.g., '/users/123')\r\n   * @param params - Optional query parameters as key-value pairs\r\n   * @returns The fully-qualified URL string with encoded query parameters\r\n   *\r\n   * @example\r\n   * Basic URL construction:\r\n   * ```typescript\r\n   * const url = builder.buildURL(\r\n   *   'https://api.example.com',\r\n   *   '/search',\r\n   *   { q: 'hello world', limit: 10 }\r\n   * );\r\n   * // => \"https://api.example.com/search?q=hello+world&limit=10\"\r\n   * ```\r\n   *\r\n   * @example\r\n   * Array parameters:\r\n   * ```typescript\r\n   * const url = builder.buildURL(\r\n   *   'https://api.example.com',\r\n   *   '/posts',\r\n   *   { tags: ['javascript', 'typescript', 'react'] }\r\n   * );\r\n   * // => \"https://api.example.com/posts?tags=javascript&tags=typescript&tags=react\"\r\n   * ```\r\n   *\r\n   * @example\r\n   * Null/undefined handling:\r\n   * ```typescript\r\n   * const url = builder.buildURL(\r\n   *   'https://api.example.com',\r\n   *   '/users',\r\n   *   {\r\n   *     name: 'John',\r\n   *     age: null,        // Skipped\r\n   *     email: undefined  // Skipped\r\n   *   }\r\n   * );\r\n   * // => \"https://api.example.com/users?name=John\"\r\n   * ```\r\n   *\r\n   * @example\r\n   * Special characters encoding:\r\n   * ```typescript\r\n   * const url = builder.buildURL(\r\n   *   'https://api.example.com',\r\n   *   '/search',\r\n   *   { q: 'foo & bar', category: 'code/examples' }\r\n   * );\r\n   * // => \"https://api.example.com/search?q=foo+%26+bar&category=code%2Fexamples\"\r\n   * ```\r\n   */\r\n  buildURL(baseURL: string, endpoint: string, params?: QueryParams): string {\r\n    const url = new URL(endpoint, baseURL);\r\n\r\n    if (params) {\r\n      Object.keys(params).forEach(key => {\r\n        const value = params[key];\r\n\r\n        if (value !== undefined && value !== null) {\r\n          if (Array.isArray(value)) {\r\n            value.forEach(v => url.searchParams.append(key, String(v)));\r\n          } else {\r\n            url.searchParams.append(key, String(value));\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    return url.toString();\r\n  }\r\n}\r\n", "import { generateCorrelationId } from './CorrelationIdGenerator';\r\nimport { ErrorNormalizer } from './Errors/ErrorNormalizer';\r\nimport { InterceptorManager } from './Interceptors/InterceptorManager';\r\nimport type {\r\n  ListResponse,\r\n  PostModel,\r\n  QueryParams,\r\n  ResponseData,\r\n} from './Models';\r\nimport { RequestManager } from './RequestManager';\r\nimport { RetryHandler } from './Retry/RetryHandler';\r\nimport { SignalManager } from './Signals/SignalManager';\r\nimport type { ApiError } from './types/ApiError';\r\nimport type { ErrorInterceptor } from './types/ErrorInterceptor';\r\nimport type { ErrorResponseData } from './types/ErrorResponseData';\r\nimport type { RequestConfig } from './types/RequestConfig';\r\nimport type { RequestInterceptor } from './types/RequestInterceptor';\r\nimport type { ResponseInterceptor } from './types/ResponseInterceptor';\r\nimport { ResponseParser } from './Utils/ResponseParser';\r\nimport { UrlBuilder } from './Utils/UrlBuilder';\r\n\r\nimport type { ApiResponse } from '@/types';\r\n\r\n/**\r\n * Enterprise-grade API client with advanced features for production applications.\r\n *\r\n * This client provides a robust, type-safe abstraction over the Fetch API with:\r\n * - Comprehensive request/response/error interceptor system\r\n * - Automatic retry logic with exponential backoff\r\n * - Request correlation ID tracking for distributed tracing\r\n * - Token-based authentication with automatic header injection\r\n * - Request cancellation and timeout management\r\n * - Type-safe error handling with structured error responses\r\n * - React Query integration support\r\n *\r\n * Architecture Principles:\r\n * - **Type Safety**: Full TypeScript inference with no `any` types\r\n * - **Extensibility**: Interceptor pattern allows for flexible middleware\r\n * - **Observability**: Built-in correlation IDs for request tracing\r\n * - **Resilience**: Automatic retries, timeouts, and graceful error handling\r\n * - **Performance**: Request deduplication and cancellation support\r\n * - **Modularity**: Organized into focused, single-responsibility modules\r\n *\r\n * @example\r\n * Basic usage:\r\n * ```typescript\r\n * const client = new ApiClient('https://api.example.com', 30000);\r\n * client.setAuthToken('your-jwt-token');\r\n *\r\n * // Type-safe GET request\r\n * const { apiData, error } = await client.get<User>('/users/123');\r\n * if (error) {\r\n *   console.error('Failed to fetch user:', error);\r\n * } else {\r\n *   console.log('User data:', data);\r\n * }\r\n * ```\r\n *\r\n * @example\r\n * With React Query:\r\n * ```typescript\r\n * const queryClient = new QueryClient();\r\n * const apiClient = new ApiClient(process.env.API_BASE_URL);\r\n *\r\n * // Add logging interceptor\r\n * apiClient.addResponseInterceptor(async (response) => {\r\n *   console.log('Response received:', response);\r\n *   return response;\r\n * });\r\n *\r\n * // Use in queries\r\n * const { apiData } = useQuery({\r\n *   queryKey: ['users', userId],\r\n *   queryFn: () => apiClient.get<User>(`/users/${userId}`)\r\n * });\r\n * ```\r\n *\r\n * @example\r\n * Advanced error handling:\r\n * ```typescript\r\n * // Option 1: Errors thrown (default)\r\n * try {\r\n *   const { apiData } = await client.get<User>('/users/123');\r\n *   console.log(data);\r\n * } catch (error) {\r\n *   if (error.status === 404) {\r\n *     console.log('User not found');\r\n *   }\r\n * }\r\n *\r\n * // Option 2: Errors returned in response\r\n * const { apiData, error } = await client.get<User>('/users/123', {\r\n *   throwErrors: false\r\n * });\r\n * if (error) {\r\n *   console.error('Request failed:', error);\r\n * }\r\n * ```\r\n *\r\n * @public\r\n */\r\nexport class ApiClient {\r\n  private readonly baseURL: string;\r\n  private readonly defaultTimeout: number;\r\n  private readonly interceptorManager: InterceptorManager =\r\n    new InterceptorManager();\r\n  private readonly signalManager: SignalManager = new SignalManager();\r\n  private readonly errorNormalizer: ErrorNormalizer = new ErrorNormalizer();\r\n  private readonly responseParser: ResponseParser = new ResponseParser();\r\n  private readonly urlBuilder: UrlBuilder = new UrlBuilder();\r\n  private readonly retryHandler: RetryHandler = new RetryHandler();\r\n  private readonly requestManager: RequestManager = new RequestManager();\r\n  private authToken: string | null = null;\r\n  private correlationIdPrefix: string = 'api';\r\n  private includeCorrelationId: boolean = true;\r\n\r\n  /**\r\n   * Creates a new API client instance\r\n   * @param baseURL - Base URL for all API requests (default: empty string for relative URLs)\r\n   * @param defaultTimeout - Default request timeout in milliseconds (default: 30000)\r\n   */\r\n  constructor(baseURL: string = '', defaultTimeout: number = 30000) {\r\n    this.baseURL = baseURL;\r\n    this.defaultTimeout = defaultTimeout;\r\n  }\r\n\r\n  /**\r\n   * Sets the prefix for auto-generated correlation IDs\r\n   * @param prefix - The prefix to use for correlation IDs (e.g., 'api', 'web', 'mobile')\r\n   */\r\n  setCorrelationIdPrefix(prefix: string): void {\r\n    this.correlationIdPrefix = prefix;\r\n  }\r\n\r\n  /**\r\n   * Enables or disables automatic correlation ID generation\r\n   * @param include - Whether to include correlation IDs in requests\r\n   */\r\n  setIncludeCorrelationId(include: boolean): void {\r\n    this.includeCorrelationId = include;\r\n  }\r\n\r\n  /**\r\n   * Registers a request interceptor to modify requests before they're sent\r\n   * @param interceptor - Function to intercept and potentially modify request config\r\n   * @returns Function to unregister this interceptor\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const unregister = client.addRequestInterceptor(async (config) => {\r\n   *   config.headers = config.headers || new Headers();\r\n   *   config.headers.set('X-Client-Version', '1.0.0');\r\n   *   return config;\r\n   * });\r\n   *\r\n   * // Later, to remove the interceptor:\r\n   * unregister();\r\n   * ```\r\n   */\r\n  addRequestInterceptor(interceptor: RequestInterceptor): () => void {\r\n    return this.interceptorManager.addRequestInterceptor(interceptor);\r\n  }\r\n\r\n  /**\r\n   * Registers a response interceptor to modify responses before they're returned\r\n   * @param interceptor - Function to intercept and potentially modify responses\r\n   * @returns Function to unregister this interceptor\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * client.addResponseInterceptor(async (response) => {\r\n   *   // Transform data format\r\n   *   if (response.apiData) {\r\n   *     response.apiData = camelCaseKeys(response.apiData);\r\n   *   }\r\n   *   return response;\r\n   * });\r\n   * ```\r\n   */\r\n  addResponseInterceptor(interceptor: ResponseInterceptor): () => void {\r\n    return this.interceptorManager.addResponseInterceptor(interceptor);\r\n  }\r\n\r\n  /**\r\n   * Registers an error interceptor to handle or transform errors\r\n   * @param interceptor - Function to intercept and potentially modify errors\r\n   * @returns Function to unregister this interceptor\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * client.addErrorInterceptor(async (error) => {\r\n   *   // Log errors to monitoring service\r\n   *   if (error.status >= 500) {\r\n   *     await monitoringService.logError(error);\r\n   *   }\r\n   *   return error; // Re-throw the error\r\n   * });\r\n   * ```\r\n   */\r\n  addErrorInterceptor(interceptor: ErrorInterceptor): () => void {\r\n    return this.interceptorManager.addErrorInterceptor(interceptor);\r\n  }\r\n\r\n  /**\r\n   * Sets the authentication token for subsequent requests\r\n   * @param token - JWT token or null to clear authentication\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * // Set token after login\r\n   * client.setAuthToken(loginResponse.accessToken);\r\n   *\r\n   * // Clear token on logout\r\n   * client.setAuthToken(null);\r\n   * ```\r\n   */\r\n  setAuthToken(token: string | null): void {\r\n    this.authToken = token;\r\n  }\r\n\r\n  /**\r\n   * Retrieves the current authentication token\r\n   * @returns The current auth token or null if not set\r\n   */\r\n  getAuthToken(): string | null {\r\n    return this.authToken;\r\n  }\r\n\r\n  /**\r\n   * Cancels a specific request by its key\r\n   * @param key - The unique key identifying the request to cancel\r\n   */\r\n  cancelRequest(key: string): void {\r\n    this.requestManager.cancel(key);\r\n  }\r\n\r\n  /**\r\n   * Cancels all pending requests\r\n   * Useful for cleanup on navigation or component unmount\r\n   */\r\n  cancelAllRequests(): void {\r\n    this.requestManager.cancelAll();\r\n  }\r\n\r\n  /**\r\n   * Core request method that handles all HTTP operations\r\n   * @template T - The expected response data type\r\n   * @param endpoint - API endpoint relative to baseURL\r\n   * @param config - Request configuration options\r\n   * @returns Promise resolving to ApiResponse with data or error\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const response = await client.request<User>('/users/123', {\r\n   *   method: 'GET',\r\n   *   timeout: 5000,\r\n   *   throwErrors: false\r\n   * });\r\n   * ```\r\n   */\r\n  async request<T = ResponseData>(\r\n    endpoint: string,\r\n    config: RequestConfig = {}\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    // Generate correlation ID\r\n    const correlationId =\r\n      config.correlationId ||\r\n      (!config.skipCorrelationId && this.includeCorrelationId\r\n        ? generateCorrelationId(this.correlationIdPrefix)\r\n        : undefined);\r\n    // Generate request key for tracking\r\n    const requestKey = `${config.method || 'GET'}_${endpoint}_${Date.now()}`;\r\n\r\n    // Create master controller for this request\r\n    const masterController = new AbortController();\r\n\r\n    try {\r\n      // Combine all abort signals\r\n      const signals: Array<AbortSignal | undefined> = [\r\n        config.signal,\r\n        config.cancelToken?.signal,\r\n        masterController.signal,\r\n      ];\r\n\r\n      // Add timeout signal if configured\r\n      const timeout = config.timeout || this.defaultTimeout;\r\n      const timeoutController = this.signalManager.createTimeoutSignal(timeout);\r\n\r\n      signals.push(timeoutController.signal);\r\n\r\n      // Create combined signal\r\n      const combinedController =\r\n        this.signalManager.createCombinedSignal(signals);\r\n\r\n      // Track this request\r\n      if (correlationId) {\r\n        this.requestManager.add(requestKey, masterController, correlationId);\r\n      }\r\n\r\n      // Apply request interceptors\r\n      const finalConfig =\r\n        await this.interceptorManager.applyRequestInterceptors({\r\n          ...config,\r\n          signal: combinedController.signal,\r\n          correlationId,\r\n        });\r\n\r\n      // Build full URL\r\n      const url = this.urlBuilder.buildURL(\r\n        this.baseURL,\r\n        endpoint,\r\n        finalConfig.params as QueryParams\r\n      );\r\n\r\n      // Add default headers\r\n      const headers = new Headers(finalConfig.headers);\r\n\r\n      // Add correlation ID header\r\n      if (correlationId) {\r\n        headers.set('X-Correlation-Id', correlationId);\r\n        headers.set('X-Request-Id', correlationId);\r\n      }\r\n\r\n      // Add auth header if token exists\r\n      if (this.authToken && !finalConfig.skipAuthRefresh) {\r\n        headers.set('Authorization', `Bearer ${this.authToken}`);\r\n      }\r\n\r\n      // Set content-type for JSON payloads\r\n\r\n      let fetchBody: BodyInit | null | undefined = finalConfig.body as\r\n        | BodyInit\r\n        | null\r\n        | undefined;\r\n\r\n      if (\r\n        finalConfig.body &&\r\n        typeof finalConfig.body === 'object' &&\r\n        !(finalConfig.body instanceof FormData) &&\r\n        !(finalConfig.body instanceof Blob) &&\r\n        !(finalConfig.body instanceof ArrayBuffer) &&\r\n        !(finalConfig.body instanceof URLSearchParams) &&\r\n        !(finalConfig.body instanceof ReadableStream)\r\n      ) {\r\n        headers.set('Content-Type', 'application/json');\r\n        fetchBody = JSON.stringify(finalConfig.body);\r\n      }\r\n\r\n      finalConfig.headers = headers;\r\n\r\n      // Create fetch promise\r\n      const fetchPromise = async (): Promise<ApiResponse<T, ApiError>> => {\r\n        try {\r\n          const response = await fetch(url, {\r\n            ...finalConfig,\r\n            body: fetchBody,\r\n            signal: combinedController.signal,\r\n          } as RequestInit);\r\n\r\n          // Parse response data\r\n          const responseData =\r\n            await this.responseParser.parseResponse(response);\r\n\r\n          // Handle error responses\r\n          if (!response.ok) {\r\n            // Cast to ErrorResponseData for structured error responses from backend\r\n            const errorData = responseData as ErrorResponseData;\r\n\r\n            const error: ApiError = Object.assign(\r\n              new Error(\r\n                errorData.title ||\r\n                  `HTTP ${response.status}: ${response.statusText}`\r\n              ),\r\n              {\r\n                type:\r\n                  errorData.type ||\r\n                  this.errorNormalizer.getErrorType(response.status),\r\n                title:\r\n                  errorData.title ||\r\n                  this.errorNormalizer.getErrorTitle(response.status),\r\n                status: response.status,\r\n                traceId: errorData.traceId || correlationId,\r\n                errors: errorData.errors,\r\n                isAborted: false,\r\n                config: finalConfig,\r\n              }\r\n            );\r\n\r\n            // Check if we should throw or return error in response\r\n            if (finalConfig.throwErrors !== false) {\r\n              throw error;\r\n            } else {\r\n              // Return error in ApiResponse.error field\r\n              return await this.interceptorManager.applyResponseInterceptors({\r\n                error,\r\n              } as ApiResponse<T, ApiError>);\r\n            }\r\n          }\r\n\r\n          // Format successful response\r\n          const apiResponse: ApiResponse<T> = {\r\n            data: responseData as T,\r\n          };\r\n\r\n          // Apply response interceptors\r\n          return await this.interceptorManager.applyResponseInterceptors(\r\n            apiResponse\r\n          );\r\n        } catch (error: unknown) {\r\n          // Handle abort errors\r\n          if ((error as Error).name === 'AbortError') {\r\n            const abortError = Object.assign(\r\n              new Error((error as Error).message || 'Request aborted'),\r\n              {\r\n                type: 'request_cancelled',\r\n                title: 'Request was cancelled',\r\n                status: 0,\r\n                traceId: correlationId,\r\n                isAborted: true,\r\n                config: finalConfig,\r\n              }\r\n            );\r\n\r\n            // Check if we should throw or return error in response\r\n            if (finalConfig.throwErrors !== false) {\r\n              throw abortError;\r\n            } else {\r\n              // Return error in ApiResponse.error field\r\n              return await this.interceptorManager.applyResponseInterceptors({\r\n                error: abortError,\r\n              } as ApiResponse<T, ApiError>);\r\n            }\r\n          }\r\n\r\n          throw error;\r\n        }\r\n      };\r\n\r\n      // Handle retries if configured\r\n      if (finalConfig.retries && finalConfig.retries > 0) {\r\n        return await this.retryHandler.retryRequest(\r\n          fetchPromise,\r\n          finalConfig.retries,\r\n          finalConfig.retryDelay || 1000,\r\n          combinedController.signal\r\n        );\r\n      }\r\n\r\n      return await fetchPromise();\r\n    } catch (error) {\r\n      // Handle errors\r\n      const apiError: ApiError = this.errorNormalizer.normalizeError(\r\n        error,\r\n        config,\r\n        correlationId\r\n      );\r\n\r\n      // Check if we should throw or return error in response\r\n      if (config.throwErrors !== false) {\r\n        await this.interceptorManager.applyErrorInterceptors(apiError);\r\n        // This line will never be reached as applyErrorInterceptors always throws,\r\n        // but TypeScript requires a return statement\r\n        throw apiError;\r\n      } else {\r\n        // Return error in ApiResponse.error field\r\n        return {\r\n          error: apiError,\r\n        } as ApiResponse<T, ApiError>;\r\n      }\r\n    } finally {\r\n      // Clean up request tracking\r\n      this.requestManager.remove(requestKey);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Performs a GET request\r\n   * @template T - The expected response data type\r\n   * @param endpoint - API endpoint\r\n   * @param config - Optional request configuration\r\n   * @returns Promise resolving to ApiResponse\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const { apiData, error } = await client.get<User[]>('/users', {\r\n   *   params: { active: true },\r\n   *   timeout: 5000\r\n   * });\r\n   * ```\r\n   */\r\n  get<T = ResponseData>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'GET' });\r\n  }\r\n\r\n  /**\r\n   * Performs a POST request\r\n   * @template T - The expected response data type\r\n   * @template TData - The request body data type\r\n   * @param endpoint - API endpoint\r\n   * @param data - Request body data\r\n   * @param config - Optional request configuration\r\n   * @returns Promise resolving to ApiResponse\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const { apiData, error } = await client.post<User, CreateUserDto>('/users', {\r\n   *   name: 'John Doe',\r\n   *   email: 'john@example.com'\r\n   * });\r\n   * ```\r\n   */\r\n  post<\r\n    T = ResponseData,\r\n    TData extends BodyInit | Record<string, unknown> | null = Record<\r\n      string,\r\n      unknown\r\n    >,\r\n  >(\r\n    endpoint: string,\r\n    data?: TData,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'POST', body: data });\r\n  }\r\n\r\n  /**\r\n   * Performs a PUT request\r\n   * @template T - The expected response data type\r\n   * @template TData - The request body data type\r\n   * @param endpoint - API endpoint\r\n   * @param data - Request body data\r\n   * @param config - Optional request configuration\r\n   * @returns Promise resolving to ApiResponse\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const { apiData, error } = await client.put<User, UpdateUserDto>(\r\n   *   '/users/123',\r\n   *   { name: 'Jane Doe' }\r\n   * );\r\n   * ```\r\n   */\r\n  put<\r\n    T = ResponseData,\r\n    TData extends BodyInit | Record<string, unknown> | null = Record<\r\n      string,\r\n      unknown\r\n    >,\r\n  >(\r\n    endpoint: string,\r\n    data?: TData,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'PUT', body: data });\r\n  }\r\n\r\n  /**\r\n   * Performs a PATCH request\r\n   * @template T - The expected response data type\r\n   * @template TData - The request body data type\r\n   * @param endpoint - API endpoint\r\n   * @param data - Request body data\r\n   * @param config - Optional request configuration\r\n   * @returns Promise resolving to ApiResponse\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const { apiData, error } = await client.patch<User>(\r\n   *   '/users/123',\r\n   *   { status: 'active' }\r\n   * );\r\n   * ```\r\n   */\r\n  patch<\r\n    T = ResponseData,\r\n    TData extends BodyInit | Record<string, unknown> | null = Record<\r\n      string,\r\n      unknown\r\n    >,\r\n  >(\r\n    endpoint: string,\r\n    data?: TData,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, {\r\n      ...config,\r\n      method: 'PATCH',\r\n      body: data,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Performs a DELETE request\r\n   * @template T - The expected response data type\r\n   * @param endpoint - API endpoint\r\n   * @param config - Optional request configuration\r\n   * @returns Promise resolving to ApiResponse\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const { error } = await client.delete('/users/123');\r\n   * if (!error) {\r\n   *   console.log('User deleted successfully');\r\n   * }\r\n   * ```\r\n   */\r\n  delete<T = ResponseData>(\r\n    endpoint: string,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<T, ApiError>> {\r\n    return this.request<T>(endpoint, { ...config, method: 'DELETE' });\r\n  }\r\n\r\n  /**\r\n   * Performs a filtered list request with pagination and sorting\r\n   * @template TListModel - The type of individual list items\r\n   * @template TFilter - The filter criteria type\r\n   * @param url - API endpoint\r\n   * @param data - Pagination and filter data\r\n   * @param config - Optional request configuration\r\n   * @returns Promise resolving to paginated list response\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * const { apiData, error } = await client.filter<User, UserFilter>(\r\n   *   '/users/filter',\r\n   *   {\r\n   *     pageOffset: 0,\r\n   *     pageSize: 20,\r\n   *     sortField: 'createdAt',\r\n   *     sortOrder: 'desc',\r\n   *     filterModel: { status: 'active' }\r\n   *   }\r\n   * );\r\n   *\r\n   * if (apiData) {\r\n   *   console.log(`Found ${apiData.Total} users`);\r\n   *   console.log('Users:', apiData.Data);\r\n   * }\r\n   * ```\r\n   */\r\n  filter<TListModel, TFilter = Record<string, unknown>>(\r\n    url: string,\r\n    data: PostModel<TFilter>,\r\n    config?: RequestConfig\r\n  ): Promise<ApiResponse<ListResponse<TListModel>, ApiError>> {\r\n    // Merge body: { ...postModel, ...postModel.filterModel }\r\n    const mergedData = { ...data, ...data.filterModel };\r\n\r\n    return this.request<ListResponse<TListModel>>(url, {\r\n      ...config,\r\n      method: 'POST',\r\n      body: mergedData,\r\n    });\r\n  }\r\n}\r\n", "/**\r\n * @fileoverview Factory functions for creating and managing ApiClient instances.\r\n *\r\n * Provides convenient factory methods for creating pre-configured ApiClient instances\r\n * with sensible defaults and automatic token management from localStorage.\r\n *\r\n * @module createApiClient\r\n */\r\n\r\nimport { ApiClient } from './ApiClient';\r\nimport type { ErrorInterceptor } from './types/ErrorInterceptor';\r\nimport type { RequestInterceptor } from './types/RequestInterceptor';\r\nimport type { ResponseInterceptor } from './types/ResponseInterceptor';\r\n\r\n/**\r\n * Configuration options for creating an ApiClient instance.\r\n *\r\n * @public\r\n */\r\nexport interface ApiClientConfig {\r\n  /**\r\n   * Base URL for all API requests.\r\n   * @example 'https://api.example.com'\r\n   */\r\n  baseURL?: string;\r\n\r\n  /**\r\n   * Default timeout for requests in milliseconds.\r\n   * @default 30000\r\n   */\r\n  timeout?: number;\r\n\r\n  /**\r\n   * Prefix for auto-generated correlation IDs (e.g., 'api', 'web', 'mobile').\r\n   * @default 'api'\r\n   */\r\n  correlationIdPrefix?: string;\r\n\r\n  /**\r\n   * Whether to automatically generate and include correlation IDs in requests.\r\n   * @default true\r\n   */\r\n  includeCorrelationId?: boolean;\r\n\r\n  /**\r\n   * Initial authentication token to set on the client.\r\n   * @default undefined\r\n   */\r\n  authToken?: string | null;\r\n\r\n  /**\r\n   * Array of request interceptors to register during client creation.\r\n   * @default []\r\n   */\r\n  requestInterceptors?: RequestInterceptor[];\r\n\r\n  /**\r\n   * Array of response interceptors to register during client creation.\r\n   * @default []\r\n   */\r\n  responseInterceptors?: ResponseInterceptor[];\r\n\r\n  /**\r\n   * Array of error interceptors to register during client creation.\r\n   * @default []\r\n   */\r\n  errorInterceptors?: ErrorInterceptor[];\r\n}\r\n\r\n/**\r\n * Global singleton ApiClient instance.\r\n * @internal\r\n */\r\nlet globalApiClient: ApiClient | null = null;\r\n\r\n/**\r\n * Creates a new ApiClient instance with sensible defaults and automatic token management.\r\n *\r\n * This factory function:\r\n * - Configures the base URL from environment variables or config\r\n * - Sets up automatic authentication token injection from localStorage ('serviceToken' key)\r\n * - Configures correlation ID generation\r\n * - Registers provided interceptors\r\n *\r\n * **Note:** Each call creates a NEW instance. Use {@link getGlobalApiClient} for singleton behavior.\r\n *\r\n * @param config - Configuration options for the API client\r\n * @returns A fully configured ApiClient instance\r\n * @public\r\n *\r\n * @example\r\n * Basic usage with defaults:\r\n * ```typescript\r\n * const client = createApiClient();\r\n * // Uses VITE_API_URL, 30s timeout, auto token from localStorage\r\n * ```\r\n *\r\n * @example\r\n * Custom configuration:\r\n * ```typescript\r\n * const client = createApiClient({\r\n *   baseURL: 'https://api.example.com',\r\n *   timeout: 60000,\r\n *   correlationIdPrefix: 'web',\r\n *   requestInterceptors: [\r\n *     async (config) => {\r\n *       console.log('Making request:', config.url);\r\n *       return config;\r\n *     }\r\n *   ]\r\n * });\r\n * ```\r\n *\r\n * @example\r\n * With React Query:\r\n * ```typescript\r\n * const apiClient = createApiClient({\r\n *   baseURL: process.env.REACT_APP_API_URL\r\n * });\r\n *\r\n * const queryClient = new QueryClient();\r\n *\r\n * function UserProfile({ userId }) {\r\n *   const { data: response } = useQuery({\r\n *     queryKey: ['user', userId],\r\n *     queryFn: () => apiClient.get(`/users/${userId}`)\r\n *   });\r\n *   const user = response?.apiData; // Access the actual data\r\n *   // ...\r\n * }\r\n * ```\r\n */\r\nexport function createApiClient(config: ApiClientConfig = {}): ApiClient {\r\n  const {\r\n    baseURL = '',\r\n    timeout = 30000,\r\n    correlationIdPrefix = 'web',\r\n    includeCorrelationId = true,\r\n    requestInterceptors = [],\r\n    responseInterceptors = [],\r\n    errorInterceptors = [],\r\n  } = config;\r\n\r\n  const client = new ApiClient(baseURL, timeout);\r\n\r\n  client.addRequestInterceptor(config => {\r\n    const token = localStorage.getItem('serviceToken');\r\n\r\n    if (token && !config.skipAuthRefresh) {\r\n      config.headers = {\r\n        ...config.headers,\r\n        Authorization: `Bearer ${token}`,\r\n      };\r\n    }\r\n\r\n    return config;\r\n  });\r\n\r\n  // Configure correlation ID\r\n  client.setCorrelationIdPrefix(correlationIdPrefix);\r\n  client.setIncludeCorrelationId(includeCorrelationId);\r\n\r\n  // // Set auth token if provided\r\n  // if (authToken !== undefined) {\r\n  //   client.setAuthToken(authToken);\r\n  // }\r\n\r\n  // Add interceptors\r\n  requestInterceptors.forEach(interceptor => {\r\n    client.addRequestInterceptor(interceptor);\r\n  });\r\n\r\n  responseInterceptors.forEach(interceptor => {\r\n    client.addResponseInterceptor(interceptor);\r\n  });\r\n\r\n  errorInterceptors.forEach(interceptor => {\r\n    client.addErrorInterceptor(interceptor);\r\n  });\r\n\r\n  return client;\r\n}\r\n\r\n/**\r\n * Gets or creates a global singleton ApiClient instance.\r\n *\r\n * This function implements the singleton pattern for ApiClient. It creates the client\r\n * on first call and returns the same instance on subsequent calls. This is useful for:\r\n * - Sharing the same client across your entire application\r\n * - Avoiding multiple instances with different configurations\r\n * - Consistent interceptor behavior app-wide\r\n *\r\n * **Important:** The config parameter is only used on the FIRST call. Subsequent calls\r\n * ignore the config and return the existing instance. Use {@link resetGlobalApiClient}\r\n * first if you need to recreate with different config.\r\n *\r\n * @param config - Configuration options (only used on first call)\r\n * @returns The global ApiClient singleton instance\r\n * @public\r\n *\r\n * @example\r\n * In your app initialization:\r\n * ```typescript\r\n * // src/lib/api.ts\r\n * export const apiClient = getGlobalApiClient({\r\n *   baseURL: 'https://api.example.com',\r\n *   timeout: 30000\r\n * });\r\n * ```\r\n *\r\n * @example\r\n * Import and use throughout your app:\r\n * ```typescript\r\n * // src/features/users/api.ts\r\n * import { getGlobalApiClient } from '@gnwebsoft/ui';\r\n *\r\n * const client = getGlobalApiClient(); // Returns same instance\r\n *\r\n * export async function fetchUsers() {\r\n *   const { apiData } = await client.get('/users');\r\n *   return apiData;\r\n * }\r\n * ```\r\n *\r\n * @example\r\n * Resetting for tests:\r\n * ```typescript\r\n * afterEach(() => {\r\n *   resetGlobalApiClient();\r\n * });\r\n *\r\n * test('creates fresh client', () => {\r\n *   const client = getGlobalApiClient({ baseURL: 'http://test.local' });\r\n *   // New instance with test config\r\n * });\r\n * ```\r\n */\r\nexport function getGlobalApiClient(config?: ApiClientConfig): ApiClient {\r\n  if (!globalApiClient) {\r\n    globalApiClient = createApiClient(config);\r\n  }\r\n\r\n  return globalApiClient;\r\n}\r\n\r\n/**\r\n * Replaces the global singleton ApiClient with a custom instance.\r\n *\r\n * Use this when you need fine-grained control over the global client instance,\r\n * such as in testing scenarios or when you've manually created a client with\r\n * specific configuration.\r\n *\r\n * @param client - The ApiClient instance to use as the global singleton\r\n * @public\r\n *\r\n * @example\r\n * Testing with a mock client:\r\n * ```typescript\r\n * const mockClient = new ApiClient('http://test.local');\r\n * mockClient.addResponseInterceptor(async (response) => {\r\n *   // Mock response data\r\n *   return { data: mockData };\r\n * });\r\n *\r\n * setGlobalApiClient(mockClient);\r\n * ```\r\n *\r\n * @example\r\n * Advanced configuration:\r\n * ```typescript\r\n * const client = new ApiClient('https://api.example.com', 60000);\r\n * client.setCorrelationIdPrefix('custom');\r\n * client.addRequestInterceptor(customInterceptor);\r\n *\r\n * setGlobalApiClient(client);\r\n * ```\r\n */\r\nexport function setGlobalApiClient(client: ApiClient): void {\r\n  globalApiClient = client;\r\n}\r\n\r\n/**\r\n * Resets the global ApiClient singleton to null.\r\n *\r\n * After calling this, the next call to {@link getGlobalApiClient} will create\r\n * a fresh instance. This is particularly useful in:\r\n * - Test cleanup to ensure test isolation\r\n * - Application logout to clear any cached state\r\n * - Hot module reloading during development\r\n *\r\n * @public\r\n *\r\n * @example\r\n * Test cleanup:\r\n * ```typescript\r\n * afterEach(() => {\r\n *   resetGlobalApiClient();\r\n * });\r\n * ```\r\n *\r\n * @example\r\n * Logout flow:\r\n * ```typescript\r\n * function handleLogout() {\r\n *   // Clear authentication\r\n *   localStorage.removeItem('serviceToken');\r\n *\r\n *   // Cancel all pending requests and reset client\r\n *   const client = getGlobalApiClient();\r\n *   client.cancelAllRequests();\r\n *   resetGlobalApiClient();\r\n *\r\n *   // Redirect to login\r\n *   navigate('/login');\r\n * }\r\n * ```\r\n */\r\nexport function resetGlobalApiClient(): void {\r\n  globalApiClient = null;\r\n}\r\n", "// CancelToken implementation\r\nexport class CancelToken {\r\n  private abortController: AbortController;\r\n  private cancelPromise: Promise<void>;\r\n  private cancelResolve?: () => void;\r\n\r\n  constructor() {\r\n    this.abortController = new AbortController();\r\n    this.cancelPromise = new Promise(resolve => {\r\n      this.cancelResolve = resolve;\r\n    });\r\n  }\r\n\r\n  get signal(): AbortSignal {\r\n    return this.abortController.signal;\r\n  }\r\n\r\n  cancel(reason?: string): void {\r\n    this.abortController.abort(reason);\r\n    this.cancelResolve?.();\r\n  }\r\n\r\n  get isCancelled(): boolean {\r\n    return this.abortController.signal.aborted;\r\n  }\r\n\r\n  throwIfCancelled(): void {\r\n    if (this.isCancelled) {\r\n      throw new Error('Request cancelled');\r\n    }\r\n  }\r\n\r\n  static source(): { token: CancelToken; cancel: (reason?: string) => void } {\r\n    const token = new CancelToken();\r\n\r\n    return {\r\n      token,\r\n      cancel: (reason?: string) => token.cancel(reason),\r\n    };\r\n  }\r\n}\r\n", "// React Hooks with ApiResponse format\r\nimport { useCallback } from 'react';\r\n\r\nimport type { ApiError } from './types';\r\n\r\n// Export factory methods and types\r\nexport {\r\n  createApiClient,\r\n  getGlobalApiClient,\r\n  setGlobalApiClient,\r\n  resetGlobalApiClient,\r\n} from './createApiClient';\r\n\r\nexport type { ApiClientConfig } from './createApiClient';\r\n\r\nexport { ApiClient } from './ApiClient';\r\n\r\n// Helper hook for form validation errors\r\nexport function useValidationErrors(error: ApiError | null) {\r\n  const getFieldError = useCallback(\r\n    (field: string): string | null => {\r\n      if (!error?.errors || !error.errors[field]) return null;\r\n\r\n      const fieldError = error.errors[field];\r\n\r\n      if (typeof fieldError === 'string') return fieldError;\r\n      if (Array.isArray(fieldError)) return fieldError[0];\r\n      if (typeof fieldError === 'object' && 'message' in fieldError) {\r\n        return fieldError.message;\r\n      }\r\n\r\n      return null;\r\n    },\r\n    [error]\r\n  );\r\n\r\n  const hasFieldError = useCallback(\r\n    (field: string): boolean => {\r\n      return !!getFieldError(field);\r\n    },\r\n    [getFieldError]\r\n  );\r\n\r\n  const getAllErrors = useCallback((): Record<string, string> => {\r\n    if (!error?.errors) return {};\r\n\r\n    const result: Record<string, string> = {};\r\n\r\n    Object.entries(error.errors).forEach(([key, value]) => {\r\n      if (typeof value === 'string') {\r\n        result[key] = value;\r\n      } else if (Array.isArray(value)) {\r\n        result[key] = value.join(', ');\r\n      } else if (typeof value === 'object' && value && 'message' in value) {\r\n        result[key] = value.message;\r\n      }\r\n    });\r\n\r\n    return result;\r\n  }, [error]);\r\n\r\n  return {\r\n    getFieldError,\r\n    hasFieldError,\r\n    getAllErrors,\r\n    hasErrors: error?.errors,\r\n  };\r\n}\r\n", "import type { PropsWithChildren } from 'react';\n\ntype AuthorizedViewProps = PropsWithChildren & {\n  show: boolean;\n};\n\nexport const AuthorizedView = ({ children, show }: AuthorizedViewProps) => {\n  if (!show) return <></>;\n\n  return <>{children}</>;\n};\n", "import type { ButtonProps } from '@mui/material';\nimport { Button } from '@mui/material';\nimport React from 'react';\n\nexport const CancelButton: React.FC<ButtonProps> = ({\n  children = 'Cancel',\n  variant = 'outlined',\n  sx,\n  ...rest\n}) => (\n  <Button variant={variant} sx={{ width: '6rem', ...sx }} {...rest}>\n    {children}\n  </Button>\n);\n", "import type { SxProps } from '@mui/material';\nimport { Button } from '@mui/material';\n\n/**\n * Props for the ClearButton component.\n *\n * @public\n */\ninterface ClearButtonProps {\n  /**\n   * Indicates if a form or operation is currently being submitted.\n   * When true, the button is disabled to prevent multiple clear actions.\n   */\n  isSubmitting: boolean;\n  /**\n   * Callback function executed when the clear button is clicked.\n   * Should handle the clearing logic (e.g., form reset, data clearing).\n   */\n  handleClear: () => void;\n  /**\n   * Optional MUI sx prop for custom styling.\n   * @example { mt: 2, color: 'warning.main' }\n   */\n  sx?: SxProps;\n  /**\n   * Optional localStorage key to remove when clearing.\n   * If provided, the corresponding localStorage item will be removed on click.\n   * @example \"user-preferences\" or \"form-data\"\n   */\n  storeKey?: string;\n}\n\n/**\n * Standardized clear button component with localStorage integration.\n *\n * This component provides a consistent clear button implementation that handles\n * both callback execution and optional localStorage cleanup. It automatically\n * disables during form submissions and can clear stored data when needed.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <ClearButton\n *   isSubmitting={isLoading}\n *   handleClear={() => form.reset()}\n * />\n * ```\n *\n * @example\n * With localStorage cleanup:\n * ```tsx\n * <ClearButton\n *   isSubmitting={form.formState.isSubmitting}\n *   handleClear={() => setFilters({})}\n *   storeKey=\"user-filters\"\n * />\n * ```\n *\n * @param props - Component props for clear button configuration\n * @returns MUI Button component configured as a clear button\n *\n * @public\n */\nexport const ClearButton = ({\n  isSubmitting,\n  handleClear,\n  sx,\n  storeKey,\n}: ClearButtonProps) => {\n  const onClick = () => {\n    handleClear();\n    if (storeKey != null) {\n      localStorage.removeItem(storeKey);\n    }\n  };\n\n  return (\n    <Button\n      variant=\"outlined\"\n      onClick={onClick}\n      disabled={isSubmitting}\n      sx={sx}\n    >\n      Clear\n    </Button>\n  );\n};\n", "import { Container, type SxProps } from '@mui/material';\nimport type { ReactNode } from 'react';\n\ninterface SimpleContainerProps {\n  children: ReactNode;\n  className?: string;\n  sx?: SxProps;\n}\n\nexport const SimpleContainer = ({\n  children,\n  className,\n  sx,\n}: SimpleContainerProps) => (\n  <Container className={className} sx={{ ...sx }}>\n    {children}\n  </Container>\n);\n", "import FilterAltIcon from '@mui/icons-material/FilterAlt';\nimport { LoadingButton } from '@mui/lab';\nimport type { SxProps } from '@mui/material';\nimport { Badge } from '@mui/material';\n\n/**\n * Props for the FilterButton component.\n *\n * @public\n */\ninterface FilterButtonProps {\n  /**\n   * Indicates if a filter operation is currently being processed.\n   * When true, shows loading spinner and disables the button.\n   */\n  isSubmitting: boolean;\n  /**\n   * Controls button visibility and enabled state.\n   * When false, the button is disabled.\n   * @defaultValue true\n   */\n  show?: boolean;\n  /**\n   * Custom text to display on the button.\n   * @defaultValue \"Filter\"\n   * @example \"Apply Filters\" or \"Search\"\n   */\n  title?: string;\n  /**\n   * Custom icon to display instead of the default filter icon.\n   * @example <SearchIcon />\n   */\n  icon?: React.ReactNode;\n  /**\n   * Optional MUI sx prop for custom button styling.\n   * @example { mt: 2, minWidth: 120 }\n   */\n  sx?: SxProps;\n  /**\n   * Optional MUI sx prop for custom icon styling.\n   * @example { color: 'primary.main', fontSize: 18 }\n   */\n  iconSx?: SxProps;\n}\n\n/**\n * Filter button component with loading states and customizable appearance.\n *\n * This component provides a standardized filter/submit button with integrated loading\n * states, icon support, and badge styling. It's designed for use in filter forms\n * and search interfaces where users need to apply filtering criteria.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <FilterButton\n *   isSubmitting={isLoading}\n *   show={hasFilters}\n * />\n * ```\n *\n * @example\n * Custom title and icon:\n * ```tsx\n * <FilterButton\n *   isSubmitting={form.formState.isSubmitting}\n *   title=\"Apply Search\"\n *   icon={<SearchIcon />}\n *   show={true}\n * />\n * ```\n *\n * @example\n * With custom styling:\n * ```tsx\n * <FilterButton\n *   isSubmitting={isProcessing}\n *   title=\"Filter Results\"\n *   sx={{ minWidth: 150, mt: 2 }}\n *   iconSx={{ fontSize: 20 }}\n * />\n * ```\n *\n * @param props - Component props for filter button configuration\n * @returns MUI LoadingButton component configured as a filter button\n *\n * @public\n */\nexport const FilterButton = ({\n  isSubmitting,\n  show,\n  title,\n  icon,\n  sx,\n  iconSx,\n}: FilterButtonProps) => {\n  return (\n    <LoadingButton\n      type=\"submit\"\n      variant=\"contained\"\n      loading={isSubmitting}\n      disabled={!show}\n      disableRipple\n      color=\"primary\"\n      sx={{\n        display: 'flex',\n        alignItems: 'center',\n        ...sx,\n      }}\n      startIcon={\n        <Badge color=\"error\" variant=\"standard\">\n          {icon ? icon : <FilterAltIcon width=\"20\" height=\"20\" sx={iconSx} />}\n        </Badge>\n      }\n    >\n      {title?.trim() === '' || !title ? 'Filter' : title}\n    </LoadingButton>\n  );\n};\n", "import Chip from '@mui/material/Chip';\nimport { memo } from 'react';\n\n// Individual chip component to prevent unnecessary rerenders of sibling chips\nexport const FilterChip = memo(\n  ({\n    fieldKey,\n    filter,\n    onDelete,\n  }: {\n    fieldKey: string;\n    filter: { Label: string; Value: unknown };\n    onDelete?: () => void;\n  }) => {\n    const hasValue =\n      filter.Value !== null &&\n      filter.Value !== undefined &&\n      filter.Value !== '';\n    const label = `${fieldKey.replace('PK', '')}: ${filter.Label}`;\n\n    return (\n      <Chip\n        key={fieldKey}\n        label={label}\n        variant={hasValue ? 'filled' : 'outlined'}\n        size=\"small\"\n        onDelete={hasValue ? onDelete : undefined}\n      />\n    );\n  }\n);\n\nFilterChip.displayName = 'FilterChip';\n", "import { Card, CardContent, Typography, Box } from '@mui/material';\nimport { memo, useMemo } from 'react';\n\nimport { FilterChip } from './FilterChip';\n\ninterface FilterDisplayProps<TFilterModel> {\n  friendlyFilter: Record<string, { Label: string; Value: unknown }>;\n  onFriendlyFilterChange?: (fieldKey: keyof TFilterModel) => void;\n}\n\nexport const ProgramsFilterDisplay = memo(\n  <TFilterModel extends Record<string, unknown>>(\n    props: FilterDisplayProps<TFilterModel>\n  ) => {\n    const { friendlyFilter, onFriendlyFilterChange } = props;\n\n    // Memoize delete handlers to prevent recreation\n    const deleteHandlers = useMemo(() => {\n      if (!onFriendlyFilterChange) return {};\n\n      const handlers: Record<string, () => void> = {};\n\n      for (const key of Object.keys(friendlyFilter)) {\n        handlers[key] = () => onFriendlyFilterChange(key as keyof TFilterModel);\n      }\n\n      return handlers;\n    }, [onFriendlyFilterChange, friendlyFilter]);\n\n    // Memoize chip list to prevent unnecessary recalculations\n    const chipList = useMemo(() => {\n      return Object.entries(friendlyFilter).map(([key, filter]) => (\n        <FilterChip\n          key={key}\n          fieldKey={key}\n          filter={filter as { Label: string; Value: unknown }}\n          onDelete={deleteHandlers[key]}\n        />\n      ));\n    }, [friendlyFilter, deleteHandlers]);\n\n    return (\n      <Card sx={{ mb: 2 }}>\n        <CardContent>\n          <Typography variant=\"h6\" gutterBottom>\n            Active Filters\n          </Typography>\n          <Box display=\"flex\" gap={1} flexWrap=\"wrap\">\n            {chipList}\n          </Box>\n        </CardContent>\n      </Card>\n    );\n  }\n);\n\nProgramsFilterDisplay.displayName = 'FilterDisplay';\n\nexport type { FilterDisplayProps };\n", "import ManageSearchIcon from '@mui/icons-material/ManageSearch';\nimport type { SxProps } from '@mui/material';\nimport {\n  Box,\n  Card,\n  CardContent,\n  CardHeader,\n  Divider,\n  Grid,\n  Typography,\n  useTheme,\n} from '@mui/material';\nimport type { PropsWithChildren, ReactNode } from 'react';\n\n/**\n * Props for the FilterWrapper component.\n *\n * @public\n */\ntype FilterWrapperProps = PropsWithChildren<{\n  /**\n   * Title text displayed in the card header.\n   * @defaultValue \"Filter\"\n   * @example \"Search Criteria\" or \"Advanced Filters\"\n   */\n  title?: string;\n  /**\n   * Number of active filters to display in the header.\n   * Only shown when showCount is true.\n   * @example 3 for \"Filter (3)\"\n   */\n  filterCount?: number;\n  /**\n   * Optional MUI sx prop for custom card styling.\n   * @example { mt: 2, boxShadow: 2 }\n   */\n  cardSx?: SxProps;\n  /**\n   * Optional MUI sx prop for custom title text styling.\n   * @example { fontSize: 18, fontWeight: 'bold' }\n   */\n  textSx?: SxProps;\n  /**\n   * Custom icon to display instead of the default search icon.\n   * @example <FilterListIcon />\n   */\n  icon?: ReactNode;\n  /**\n   * Optional MUI sx prop for custom icon styling.\n   * @example { color: 'secondary.main', fontSize: 24 }\n   */\n  iconSx?: SxProps;\n  /**\n   * Whether to display the filter count in the header.\n   * @defaultValue false\n   */\n  showCount?: boolean;\n}>;\n\n/**\n * Card-based wrapper component for organizing filter controls and form elements.\n *\n * This component provides a consistent layout for filter interfaces with a header,\n * optional filter count display, and a grid-based content area. It's designed to\n * contain form controls and filter elements in a visually organized manner.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <FilterWrapper>\n *   <Grid item xs={12} md={6}>\n *     <TextField label=\"Search\" />\n *   </Grid>\n *   <Grid item xs={12} md={6}>\n *     <Select label=\"Category\" />\n *   </Grid>\n * </FilterWrapper>\n * ```\n *\n * @example\n * With custom title and count:\n * ```tsx\n * <FilterWrapper\n *   title=\"Advanced Search\"\n *   filterCount={activeFilters.length}\n *   showCount={true}\n * >\n *   {filterControls}\n * </FilterWrapper>\n * ```\n *\n * @example\n * With custom styling:\n * ```tsx\n * <FilterWrapper\n *   title=\"Product Filters\"\n *   icon={<FilterListIcon />}\n *   cardSx={{ mt: 3, borderRadius: 2 }}\n *   textSx={{ color: 'secondary.main' }}\n * >\n *   {children}\n * </FilterWrapper>\n * ```\n *\n * @param props - Component props including children and styling options\n * @returns MUI Card component with structured filter layout\n *\n * @public\n */\nexport const FilterWrapper = ({\n  children,\n  title,\n  filterCount,\n  cardSx,\n  textSx,\n  icon,\n  iconSx,\n  showCount,\n}: FilterWrapperProps) => {\n  const theme = useTheme();\n\n  return (\n    <Card\n      sx={{\n        position: 'relative',\n        borderRadius: '0px',\n        mb: 2,\n        ...cardSx,\n      }}\n    >\n      <CardHeader\n        sx={{\n          display: 'flex',\n          flexWrap: 'wrap',\n          p: '1rem',\n          '.MuiCardHeader-action': {\n            margin: 0,\n            alignSelf: 'center',\n          },\n          alignItems: 'center',\n        }}\n        title={\n          <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>\n            {icon ? (\n              icon\n            ) : (\n              <ManageSearchIcon\n                sx={{\n                  height: '2.5rem',\n                  color: theme.palette.primary.main,\n                  ...iconSx,\n                }}\n              />\n            )}\n            <Typography\n              variant=\"h5\"\n              sx={{\n                fontWeight: 'bold',\n                color: theme.palette.primary.main,\n                ...textSx,\n              }}\n            >\n              {title ? title : 'Filter'}{' '}\n              {showCount ? `(${filterCount ? filterCount : 0})` : <></>}\n            </Typography>\n          </Box>\n        }\n      ></CardHeader>\n      <Divider />\n      <CardContent sx={{ py: 2 }}>\n        <Grid container spacing={2}>\n          {children}\n        </Grid>\n      </CardContent>\n    </Card>\n  );\n};\n", "// core/components/Footer/index.tsx\nimport { Box, Typography } from '@mui/material';\nimport React from 'react';\n\nexport const Footer: React.FC = () => {\n  const currentYear = new Date().getFullYear();\n\n  return (\n    <Box\n      component=\"footer\"\n      sx={{\n        py: 2,\n        px: 4,\n        mt: 'auto',\n        backgroundColor: theme =>\n          theme.palette.mode === 'light'\n            ? theme.palette.grey[200]\n            : theme.palette.grey[800],\n      }}\n    >\n      <Typography variant=\"body2\" color=\"text.secondary\" align=\"center\">\n        {`\u00A9 Copyright ${currentYear} GN. All rights reserved by Parul University.`}\n      </Typography>\n    </Box>\n  );\n};\n", "import type { SxProps } from '@mui/material';\nimport { Grid, Tooltip, Typography } from '@mui/material';\n\n/**\n * Props for the LabelText component.\n *\n * @public\n */\ninterface LabelTextProps {\n  /**\n   * Label text to display on the left side.\n   * @example \"Name\" or \"Email Address\"\n   */\n  label: string;\n  /**\n   * Value content to display on the right side.\n   * Can be text, numbers, or React elements.\n   * @example \"John Doe\" or <Link>View Details</Link>\n   */\n  value: React.ReactNode;\n  /**\n   * Custom grid sizing for label and value sections.\n   * @defaultValue { labelSize: { xs: 6, sm: 6, md: 6 }, valueSize: { xs: 12, sm: 6, md: 6 } }\n   */\n  gridSize?: {\n    /** Grid size configuration for the label section */\n    labelSize: { xs: number; sm: number; md: number };\n    /** Grid size configuration for the value section */\n    valueSize: { xs: number; sm: number; md: number };\n  };\n  /**\n   * Grid size configuration for the entire container.\n   * @defaultValue { xs: 12, sm: 6, md: 6 }\n   */\n  containerSize?: { xs: number; sm: number; md: number };\n  /**\n   * Optional MUI sx prop for custom label styling.\n   * @example { fontWeight: 'bold', color: 'primary.main' }\n   */\n  labelSx?: SxProps;\n  /**\n   * Optional MUI sx prop for custom value styling.\n   * @example { color: 'text.secondary', fontStyle: 'italic' }\n   */\n  valueSx?: SxProps;\n}\n\n/**\n * Responsive label-value display component with hover effects and text truncation.\n *\n * This component creates a consistent label-value pair layout that adapts to different\n * screen sizes. It includes hover effects, text truncation with tooltips, and\n * customizable grid sizing for flexible layouts.\n *\n * @example\n * Basic usage:\n * ```tsx\n * <LabelText\n *   label=\"Full Name\"\n *   value=\"John Doe\"\n * />\n * ```\n *\n * @example\n * With React element value:\n * ```tsx\n * <LabelText\n *   label=\"Profile\"\n *   value={<Link href=\"/profile\">View Profile</Link>}\n * />\n * ```\n *\n * @example\n * Custom grid sizing:\n * ```tsx\n * <LabelText\n *   label=\"Description\"\n *   value={longDescription}\n *   gridSize={{\n *     labelSize: { xs: 12, sm: 3, md: 2 },\n *     valueSize: { xs: 12, sm: 9, md: 10 }\n *   }}\n *   containerSize={{ xs: 12, sm: 12, md: 12 }}\n * />\n * ```\n *\n * @param props - Component props for label-value configuration\n * @returns Grid-based layout with label and value sections\n *\n * @public\n */\nexport const LabelText = ({\n  label,\n  value,\n  gridSize,\n  containerSize,\n  labelSx,\n  valueSx,\n}: LabelTextProps) => {\n  const defaultGridSize = {\n    labelSize: { xs: 6, sm: 6, md: 6 },\n    valueSize: { xs: 12, sm: 6, md: 6 },\n  };\n  const defaultContainerSize = { xs: 12, sm: 6, md: 6 };\n  const size = gridSize || defaultGridSize;\n  const container = containerSize || defaultContainerSize;\n\n  return (\n    <Grid\n      size={container}\n      sx={{\n        display: 'flex',\n        flexDirection: { xs: 'column', sm: 'row', md: 'row' },\n        '&:hover': { bgcolor: '#efefef', overflow: 'hidden' },\n      }}\n    >\n      <Grid\n        size={size.labelSize}\n        sx={{\n          padding: '5px',\n          fontSize: '14px',\n          textAlign: { xs: 'left', sm: 'right', md: 'right' },\n          ...labelSx,\n        }}\n      >\n        {label} :\n      </Grid>\n      <Grid\n        size={size.valueSize}\n        sx={{ padding: '5px', display: 'flex', flexWrap: 'wrap' }}\n      >\n        <Tooltip title={value} arrow>\n          <Typography\n            sx={{\n              fontSize: '14px',\n              wordBreak: 'break-word',\n              overflow: 'hidden',\n              display: '-webkit-box',\n              textOverflow: 'ellipsis',\n              WebkitLineClamp: 2,\n              WebkitBoxOrient: 'vertical',\n              ...valueSx,\n              color: '#078dee',\n            }}\n          >\n            {value ? value : '-'}\n          </Typography>\n        </Tooltip>\n      </Grid>\n    </Grid>\n  );\n};\n", "import type { PropsWithChildren } from 'react';\n\ninterface RenderIfProps {\n  show: boolean;\n}\n\nexport const RenderIf = ({\n  show,\n  children,\n}: PropsWithChildren<RenderIfProps>) => {\n  return show ? <>{children}</> : null;\n};\n", "import type { SxProps, Theme } from '@mui/material';\nimport { Box, Divider, Grid, Stack, Typography } from '@mui/material';\nimport type { PropsWithChildren, ReactNode } from 'react';\nimport { memo, useMemo } from 'react';\n\n// Section box configuration\nexport interface SectionBoxProps extends PropsWithChildren {\n  title: string;\n  spacing?: number;\n  containerSx?: SxProps<Theme>;\n  titleSx?: SxProps<Theme>;\n  variant?: 'default' | 'form' | 'info' | 'warning' | 'error';\n  icon?: ReactNode;\n  actions?: ReactNode;\n  collapsible?: boolean;\n  defaultExpanded?: boolean;\n}\n\n// Theme configuration for section variants\nconst getSectionTheme = (variant: SectionBoxProps['variant'] = 'default') => {\n  const themes = {\n    default: {\n      bgcolor: '#faebd7',\n      color: '#925d21',\n    },\n    form: {\n      bgcolor: '#cdced1',\n      color: 'black',\n    },\n    info: {\n      bgcolor: '#e3f2fd',\n      color: '#1976d2',\n    },\n    warning: {\n      bgcolor: '#fff3e0',\n      color: '#f57c00',\n    },\n    error: {\n      bgcolor: '#ffebee',\n      color: '#d32f2f',\n    },\n  };\n\n  return themes[variant];\n};\n\n// Memoized SectionBox component for performance\nexport const SectionBox = memo<SectionBoxProps>(\n  ({\n    title,\n    children,\n    spacing = 0,\n    containerSx,\n    titleSx,\n    variant = 'default',\n    icon,\n    actions,\n  }) => {\n    const themeColors = useMemo(() => getSectionTheme(variant), [variant]);\n\n    const headerSx = useMemo(\n      () => ({\n        px: 1.5,\n        py: 0.1,\n        width: 'fit-content',\n        ...themeColors,\n        ...titleSx,\n      }),\n      [themeColors, titleSx]\n    );\n\n    const contentSx = useMemo(\n      () => ({\n        padding: '16px',\n        ...containerSx,\n      }),\n      [containerSx]\n    );\n\n    return (\n      <>\n        <Box sx={{ display: 'flex', flexDirection: 'column', width: '100%' }}>\n          <Stack\n            direction=\"row\"\n            justifyContent=\"space-between\"\n            alignItems=\"center\"\n            sx={headerSx}\n          >\n            <Stack direction=\"row\" alignItems=\"center\" spacing={1}>\n              {icon}\n              <Typography sx={{ fontSize: '15px', fontWeight: 400 }}>\n                {title}\n              </Typography>\n            </Stack>\n            {actions}\n          </Stack>\n          <Divider />\n        </Box>\n        <Grid container spacing={spacing} sx={contentSx}>\n          {children}\n        </Grid>\n      </>\n    );\n  }\n);\n", "import { TabContext } from '@mui/lab';\nimport type { SxProps } from '@mui/material';\nimport { Box, Tab, Tabs } from '@mui/material';\nimport type { PropsWithChildren } from 'react';\nimport React, { useState } from 'react';\n\nexport interface TabItem {\n  label: string;\n  value: number;\n  permission?: boolean;\n}\n\ninterface CustomTabsProps {\n  tabs: TabItem[];\n  defaultValue?: number;\n  onTabChange?: (newValue: number) => void;\n  tabSx?: SxProps;\n  tabsSx?: SxProps;\n}\n\nexport const SimpleTabs = ({\n  tabs,\n  defaultValue = 1,\n  onTabChange,\n  children,\n  tabSx,\n  tabsSx,\n}: CustomTabsProps & PropsWithChildren) => {\n  const [value, setValue] = useState<number>(defaultValue);\n\n  const handleChange = (event: React.SyntheticEvent, newValue: number) => {\n    setValue(newValue);\n    if (onTabChange) onTabChange(newValue);\n  };\n\n  return (\n    <TabContext value={value}>\n      <Box sx={{ borderBottom: 1, borderColor: 'divider', width: '100%' }}>\n        <Tabs\n          value={value}\n          onChange={handleChange}\n          sx={{ px: 2, py: 0, ...tabsSx }}\n        >\n          {tabs.map(tab => (\n            <Tab\n              key={tab.value}\n              label={tab.label}\n              value={tab.value}\n              disabled={tab.permission === false}\n              sx={{ fontSize: '1rem', ...tabSx }}\n            />\n          ))}\n        </Tabs>\n      </Box>\n\n      {children}\n    </TabContext>\n  );\n};\n", "import type { LoadingButtonProps } from '@mui/lab';\nimport { LoadingButton } from '@mui/lab';\nimport React from 'react';\n\ntype SubmitButtonProps = Omit<\n  LoadingButtonProps,\n  'children' | 'variant' | 'color' | 'type'\n>;\n\nexport const SubmitButton: React.FC<SubmitButtonProps> = ({\n  loading = false,\n  ...rest\n}) => (\n  <LoadingButton\n    loading={loading}\n    variant=\"contained\"\n    color=\"primary\"\n    type=\"submit\"\n    {...rest}\n    sx={{ fontWeight: 400 }}\n  >\n    Submit\n  </LoadingButton>\n);\n", "import type React from 'react';\nimport { forwardRef } from 'react';\n\n// ----------------------\n// Shared types\n// ----------------------\nexport interface DataModalButtons {\n  onSubmit?: () => void;\n  onCancel?: () => void;\n  isPending?: boolean;\n  isSuccess?: boolean;\n}\n\nexport interface DataModalComponentProps<TData> {\n  data?: TData;\n  isEditing?: boolean;\n  ref?: React.Ref<DataModalButtons>; // \uD83D\uDC48 put ref into props\n}\n\n// ----------------------\n// Project-specific HOC\n// ----------------------\nexport function withDataModal<TData>(\n  component: (\n    props: DataModalComponentProps<TData>\n  ) => React.ReactElement | null\n) {\n  return forwardRef<DataModalButtons, DataModalComponentProps<TData>>(\n    (props, ref) => component({ ...props, ref })\n  );\n}\n", "export interface ConfigValue {\n  apiBaseUrl: string;\n  defaultPageSize: number;\n}\n\nexport const Config: ConfigValue = {\n  defaultPageSize: 20,\n  apiBaseUrl: 'http://localhost:5143',\n  // apiBaseUrl: 'http://192.168.1.246:5143',\n};\n\nexport const dateTimePatterns = {\n  dateTime: 'DD MMM YYYY h:mm A', // 17 Apr 2022 12:00 am\n  date: 'DD MMM YYYY', // 17 Apr 2022\n  month_year_short_format: 'MMM YYYY',\n  month_year_full_format: 'MMMM YYYY',\n  year: 'YYYY',\n  time: 'h:mm a', // 12:00 am\n  split: {\n    dateTime: 'DD/MM/YYYY h:mm A', // 17/04/2022 12:00 am\n    date: 'DD/MM/YYYY', // 17/04/2022\n  },\n  paramCase: {\n    dateTime: 'DD-MM-YYYY h:mm A', // 17-04-2022 12:00 am\n    date: 'DD-MM-YYYY', // 17-04-2022\n    dateReverse: 'YYYY-MM-DD', // 2022-04-17 for compare date\n    MonthYear: 'MMM-YYYY',\n  },\n};\n", "import { useMemo } from 'react';\n\nimport { createApiClient } from '../api/createApiClient';\nimport type { ApiClientConfig } from '../api/createApiClient';\n\nexport function useApiClient(config: ApiClientConfig = {}) {\n  return useMemo(\n    () => createApiClient(config),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [\n      config.baseURL,\n      config.timeout,\n      config.correlationIdPrefix,\n      config.includeCorrelationId,\n      config.authToken,\n      config.requestInterceptors,\n      config.responseInterceptors,\n      config.errorInterceptors,\n    ]\n  );\n}\n", "import type { ValidationErrors } from '@gnwebsoft/ui';\nimport { useCallback } from 'react';\nimport type { UseFormSetError, FieldValues, Path } from 'react-hook-form';\nimport { toast } from 'sonner';\n\nimport type { ApiError } from '../api/types';\n\nexport interface SuccessMessage {\n  create: string;\n  update: string;\n}\n\nexport interface ErrorMessage {\n  noChanges: string;\n  general: string;\n}\n\nexport interface UseFormErrorHandlerOptions<TFieldValues extends FieldValues> {\n  setError?: UseFormSetError<TFieldValues>;\n  successMessage?: SuccessMessage;\n  errorMessage?: ErrorMessage;\n}\n\nexport type SuccessHandler = (\n  isEditing: boolean,\n  rowsAffected?: number\n) => boolean;\n\nexport type ErrorHandler = (processedError: ApiError) => void;\n\nexport interface UseFormErrorHandlerReturn {\n  handleSuccess: SuccessHandler;\n  handleError: ErrorHandler;\n}\n\nexport interface UseDeleteHandlerOptions {\n  successMessage?: string;\n  errorMessage?: string;\n}\n\n/**\n * Hook to handle API errors in forms with standardized error handling and toast messages\n */\nexport const useFormErrorHandler = <TFieldValues extends FieldValues>({\n  setError,\n  successMessage = {\n    create: 'Created successfully',\n    update: 'Updated successfully',\n  },\n  errorMessage = {\n    noChanges: 'No changes were made',\n    general: 'Failed to save. Please try again.',\n  },\n}: UseFormErrorHandlerOptions<TFieldValues>): UseFormErrorHandlerReturn => {\n  const getFieldError = useCallback(\n    (\n      fields: ValidationErrors | undefined,\n      fieldName: string\n    ): string | undefined => {\n      if (!fields || !fields[fieldName]) return undefined;\n\n      const fieldError = fields[fieldName];\n\n      if (typeof fieldError === 'string') {\n        return fieldError;\n      }\n\n      if (Array.isArray(fieldError)) {\n        return fieldError.join(', ');\n      }\n\n      if (typeof fieldError === 'object' && 'message' in fieldError) {\n        return fieldError.message;\n      }\n\n      return undefined;\n    },\n    []\n  );\n\n  const handleSuccess = useCallback(\n    (isEditing: boolean, rowsAffected?: number) => {\n      if (rowsAffected !== undefined && rowsAffected > 0) {\n        toast.success(\n          isEditing ? successMessage.update : successMessage.create\n        );\n\n        return true;\n      } else if (rowsAffected === 0) {\n        toast.error(errorMessage.noChanges);\n\n        return false;\n      }\n\n      // If rowsAffected is undefined, assume success\n      toast.success(isEditing ? successMessage.update : successMessage.create);\n\n      return true;\n    },\n    [successMessage, errorMessage]\n  );\n\n  const handleError = useCallback(\n    (processedError: ApiError) => {\n      if (\n        processedError.type === 'validation_error' &&\n        processedError.errors &&\n        setError\n      ) {\n        // Set field-specific errors using react-hook-form's setError (only if setError is provided)\n        Object.keys(processedError.errors).forEach(fieldName => {\n          const fieldError = getFieldError(processedError.errors, fieldName);\n\n          if (fieldError) {\n            setError(fieldName as Path<TFieldValues>, {\n              type: 'server',\n              message: fieldError,\n            });\n          }\n        });\n\n        // Show general validation error toast\n        toast.error(\n          processedError.title || 'Please check the form for validation errors'\n        );\n      } else {\n        // Show general error toast for non-validation errors or when setError is not available\n        toast.error(processedError.title || errorMessage.general);\n      }\n    },\n    [errorMessage.general, getFieldError, setError]\n  );\n\n  return {\n    handleSuccess,\n    handleError,\n  };\n};\n\n/**\n * Convenience hook for delete operations that don't need form field validation\n * Uses useFormErrorHandler internally but with simplified options\n */\nexport const useDeleteHandler = ({\n  successMessage = 'Deleted successfully',\n  errorMessage = 'Failed to delete. Please try again.',\n}: UseDeleteHandlerOptions = {}): UseFormErrorHandlerReturn => {\n  return useFormErrorHandler({\n    successMessage: {\n      create: successMessage, // Not used for delete, but required for type\n      update: successMessage,\n    },\n    errorMessage: {\n      noChanges: 'No changes were made', // Not typically used for delete\n      general: errorMessage,\n    },\n    // setError is omitted (undefined) for delete operations\n  });\n};\n", "import type { QueryClient, QueryKey } from '@tanstack/react-query';\nimport { useQueryClient } from '@tanstack/react-query';\nimport { useMemo } from 'react';\n\n// Minimal type-safe cache utility for query key factories\nexport class CacheUtility {\n  constructor(private queryClient: QueryClient) {}\n\n  /**\n   * Get cached data using only the queryKey from query factory\n   */\n  getCachedData<T>(queryKey: QueryKey): T | undefined {\n    return this.queryClient.getQueryData<T>(queryKey);\n  }\n\n  /**\n   * Get cached data with transformation using select function\n   */\n  getCachedDataWithSelect<T, R>(\n    queryKey: QueryKey,\n    select: (data: T) => R\n  ): R | undefined {\n    const cachedData = this.queryClient.getQueryData<T>(queryKey);\n\n    if (cachedData === undefined) {\n      return undefined;\n    }\n\n    return select(cachedData);\n  }\n}\n\nexport function useCacheUtility(): CacheUtility {\n  const queryClient = useQueryClient();\n\n  return useMemo(() => new CacheUtility(queryClient), [queryClient]);\n}\n", "import type {\n  Control,\n  DeepPartialSkipArrayKey,\n  FieldValues,\n  Path,\n  PathValue,\n} from 'react-hook-form';\nimport { useWatch } from 'react-hook-form';\n\n/**\n * Core watch functions for React Hook Form\n * These are the primary building blocks for form watching\n */\n\n/**\n * Utility type to ensure array elements are all Path<T>\n */\nexport type PathArray<T extends FieldValues> = ReadonlyArray<Path<T>>;\n\n/**\n * Hook to watch entire form - returns all form values\n */\nexport const useWatchForm = <TFieldValues extends FieldValues>(\n  control: Control<TFieldValues>\n): DeepPartialSkipArrayKey<TFieldValues> => useWatch({ control });\n\n/**\n * Hook to watch single field by path - supports any nested path\n */\nexport const useWatchField = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n>(\n  control: Control<TFieldValues>,\n  name: TName\n): PathValue<TFieldValues, TName> => useWatch({ control, name });\n\n/**\n * Hook to watch multiple fields by paths - returns array of values\n */\nexport const useWatchFields = <\n  TFieldValues extends FieldValues,\n  TNames extends ReadonlyArray<Path<TFieldValues>>,\n>(\n  control: Control<TFieldValues>,\n  names: TNames\n): Array<PathValue<TFieldValues, TNames[number]>> =>\n  useWatch({ control, name: names }) as Array<\n    PathValue<TFieldValues, TNames[number]>\n  >;\n", "import { useEffect, useMemo, useState } from 'react';\nimport type { Control, FieldValues, Path, PathValue } from 'react-hook-form';\nimport { useWatch } from 'react-hook-form';\n\n/**\n * Utility watch functions for React Hook Form\n * Enhanced functionality for specific use cases\n */\n\n/**\n * Watch field with transformation/selector\n */\nexport const useWatchTransform = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n  TOutput,\n>(\n  control: Control<TFieldValues>,\n  name: TName,\n  transform: (value: PathValue<TFieldValues, TName>) => TOutput\n): TOutput => {\n  const value = useWatch({ control, name });\n\n  return useMemo(() => transform(value), [value, transform]);\n};\n\n/**\n * Watch field with default fallback value\n */\nexport const useWatchDefault = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n>(\n  control: Control<TFieldValues>,\n  name: TName,\n  defaultValue: PathValue<TFieldValues, TName>\n): PathValue<TFieldValues, TName> => {\n  const value = useWatch({ control, name });\n\n  return value ?? defaultValue;\n};\n\n/**\n * Watch field as boolean with guaranteed boolean return\n */\nexport const useWatchBoolean = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n>(\n  control: Control<TFieldValues>,\n  name: TName,\n  defaultValue = false\n): boolean => {\n  const value = useWatch({ control, name });\n\n  return Boolean(value ?? defaultValue);\n};\n\n/**\n * Watch multiple fields and return an object with field paths as keys\n */\nexport const useWatchBatch = <\n  TFieldValues extends FieldValues,\n  TFields extends ReadonlyArray<Path<TFieldValues>>,\n>(\n  control: Control<TFieldValues>,\n  fields: TFields\n): { [K in TFields[number]]: PathValue<TFieldValues, K> } => {\n  const values = useWatch({ control, name: fields });\n\n  return useMemo(() => {\n    const result = {} as { [K in TFields[number]]: PathValue<TFieldValues, K> };\n\n    fields.forEach((field, index) => {\n      result[field as TFields[number]] = values[index];\n    });\n\n    return result;\n  }, [values, fields]);\n};\n\n/**\n * Watch field conditionally based on boolean flag\n */\nexport const useWatchConditional = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n>(\n  control: Control<TFieldValues>,\n  name: TName,\n  shouldWatch: boolean,\n  fallback?: PathValue<TFieldValues, TName>\n): PathValue<TFieldValues, TName> | undefined => {\n  const activeValue = useWatch({\n    control,\n    name,\n    disabled: !shouldWatch,\n  });\n\n  return shouldWatch ? activeValue : fallback;\n};\n\n/**\n * Watch field with debounced updates\n */\nexport const useWatchDebounced = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n>(\n  control: Control<TFieldValues>,\n  name: TName,\n  delay = 300\n): PathValue<TFieldValues, TName> => {\n  const value = useWatch({ control, name });\n  const [debouncedValue, setDebouncedValue] =\n    useState<PathValue<TFieldValues, TName>>(value);\n\n  useEffect(() => {\n    const timer = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delay);\n\n    return () => clearTimeout(timer);\n  }, [value, delay]);\n\n  return debouncedValue;\n};\n\n/**\n * Watch field with memoized selector function\n */\nexport const useWatchSelector = <\n  TFieldValues extends FieldValues,\n  TName extends Path<TFieldValues>,\n  TOutput,\n>(\n  control: Control<TFieldValues>,\n  name: TName,\n  selector: (value: PathValue<TFieldValues, TName>) => TOutput,\n  deps: React.DependencyList = []\n): TOutput => {\n  const value = useWatch({ control, name });\n\n  return useMemo(\n    () => selector(value),\n    [value, selector, ...deps] // eslint-disable-line react-hooks/exhaustive-deps\n  );\n};\n", "/**\n * Enhanced TypeScript utilities for React Hook Form's useWatch\n *\n * This module provides a comprehensive set of type-safe watch functions\n * with better ergonomics and additional functionality.\n *\n * @example\n * ```typescript\n * import { useWatchField, useWatchBoolean, typedWatch } from 'src/utils/watch';\n *\n * // Direct usage (inside React components)\n * const email = useWatchField(control, 'user.email');\n * const isAdmin = useWatchBoolean(control, 'user.isAdmin');\n *\n * // Object-based usage (inside React components)\n * const email = typedWatch.field(control, 'user.email');\n * const isAdmin = typedWatch.boolean(control, 'user.isAdmin');\n * ```\n */\n\n// Core functions\nexport { useWatchField, useWatchFields, useWatchForm } from './core';\n\n// Utility functions\nexport {\n  useWatchBatch,\n  useWatchBoolean,\n  useWatchConditional,\n  useWatchDebounced,\n  useWatchDefault,\n  useWatchSelector,\n  useWatchTransform,\n} from './utilities';\n\nexport type { PathArray } from './core';\n\n// Import all functions for default export\nimport { useWatchField, useWatchFields, useWatchForm } from './core';\nimport {\n  useWatchBatch,\n  useWatchBoolean,\n  useWatchConditional,\n  useWatchDebounced,\n  useWatchDefault,\n  useWatchSelector,\n  useWatchTransform,\n} from './utilities';\n\n/**\n * Organized utilities by use case\n * Provides a convenient object-based API for all watch functions\n */\nexport const typedWatch = {\n  // === CORE FUNCTIONS ===\n  /** Watch entire form */\n  form: useWatchForm,\n  /** Watch single field */\n  field: useWatchField,\n  /** Watch multiple fields */\n  fields: useWatchFields,\n\n  // === UTILITY FUNCTIONS ===\n  /** Watch with transformation */\n  transform: useWatchTransform,\n  /** Watch with default value */\n  withDefault: useWatchDefault,\n  /** Watch as boolean */\n  boolean: useWatchBoolean,\n  /** Watch multiple with custom keys */\n  batch: useWatchBatch,\n  /** Watch conditionally */\n  conditional: useWatchConditional,\n  /** Watch with debouncing */\n  debounced: useWatchDebounced,\n  /** Watch with selector */\n  selector: useWatchSelector,\n} as const;\n", "export const calculateFilterCount = (model: object): number =>\n  Object.values(model).filter(\n    v => v !== null && v !== undefined && String(v).trim() !== ''\n  ).length;\n", "import type { Dayjs, OpUnitType } from 'dayjs';\nimport dayjs from 'dayjs';\nimport duration from 'dayjs/plugin/duration';\nimport relativeTime from 'dayjs/plugin/relativeTime';\n\n// ----------------------------------------------------------------------\n\n/**\n * @Docs\n * https://day.js.org/docs/en/display/format\n */\n\n/**\n * Default timezones\n * https://day.js.org/docs/en/timezone/set-default-timezone#docsNav\n *\n */\n\n/**\n * UTC\n * https://day.js.org/docs/en/plugin/utc\n * @install\n * import utc from 'dayjs/plugin/utc';\n * dayjs.extend(utc);\n * @usage\n * dayjs().utc().format()\n *\n */\n\ndayjs.extend(duration);\ndayjs.extend(relativeTime);\n\n// ----------------------------------------------------------------------\n\nexport type DatePickerFormat =\n  | Dayjs\n  | Date\n  | string\n  | number\n  | null\n  | undefined;\n\nexport const formatPatterns = {\n  dateTime: 'DD MMM YYYY h:mm A', // 17 Apr 2022 12:00 am\n  date: 'DD MMM YYYY', // 17 Apr 2022\n  month_year_short_format: 'MMM YYYY',\n  month_year_full_format: 'MMMM YYYY',\n  year: 'YYYY',\n  time: 'h:mm a', // 12:00 am\n  split: {\n    dateTime: 'DD/MM/YYYY h:mm A', // 17/04/2022 12:00 am\n    date: 'DD/MM/YYYY', // 17/04/2022\n  },\n  paramCase: {\n    dateTime: 'DD-MM-YYYY h:mm A', // 17-04-2022 12:00 am\n    date: 'DD-MM-YYYY', // 17-04-2022\n    dateReverse: 'YYYY-MM-DD', // 2022-04-17 for compare date\n    MonthYear: 'MMM-YYYY',\n  },\n};\n\nconst isValidDate = (date: DatePickerFormat) =>\n  date !== null && date !== undefined && dayjs(date).isValid();\n\n// ----------------------------------------------------------------------\n\nexport function today(template?: string): string {\n  return dayjs(new Date()).startOf('day').format(template);\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output 17 Apr 2022 12:00 am\n */\nexport function fDateTime(date: DatePickerFormat, template?: string): string {\n  if (!isValidDate(date)) {\n    return 'Invalid date';\n  }\n\n  return dayjs(date).format(template ?? formatPatterns.dateTime);\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output 17 Apr 2022\n */\nexport function fDate(date: DatePickerFormat, template?: string): string {\n  if (!isValidDate(date)) {\n    return 'Invalid date';\n  }\n\n  return dayjs(date).format(template ?? formatPatterns.date);\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output 12:00 am\n */\nexport function fTime(date: DatePickerFormat, template?: string): string {\n  if (!isValidDate(date)) {\n    return 'Invalid date';\n  }\n\n  return dayjs(date).format(template ?? formatPatterns.time);\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output 1713250100\n */\nexport function fTimestamp(date: DatePickerFormat): number | 'Invalid date' {\n  if (!isValidDate(date)) {\n    return 'Invalid date';\n  }\n\n  return dayjs(date).valueOf();\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output a few seconds, 2 years\n */\nexport function fToNow(date: DatePickerFormat): string {\n  if (!isValidDate(date)) {\n    return 'Invalid date';\n  }\n\n  return dayjs(date).toNow(true);\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output boolean\n */\nexport function fIsBetween(\n  inputDate: DatePickerFormat,\n  startDate: DatePickerFormat,\n  endDate: DatePickerFormat\n): boolean {\n  if (\n    !isValidDate(inputDate) ||\n    !isValidDate(startDate) ||\n    !isValidDate(endDate)\n  ) {\n    return false;\n  }\n\n  const formattedInputDate = fTimestamp(inputDate);\n  const formattedStartDate = fTimestamp(startDate);\n  const formattedEndDate = fTimestamp(endDate);\n\n  if (\n    formattedInputDate === 'Invalid date' ||\n    formattedStartDate === 'Invalid date' ||\n    formattedEndDate === 'Invalid date'\n  ) {\n    return false;\n  }\n\n  return (\n    formattedInputDate >= formattedStartDate &&\n    formattedInputDate <= formattedEndDate\n  );\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output boolean\n */\nexport function fIsAfter(\n  startDate: DatePickerFormat,\n  endDate: DatePickerFormat\n): boolean {\n  if (!isValidDate(startDate) || !isValidDate(endDate)) {\n    return false;\n  }\n\n  return dayjs(startDate).isAfter(endDate);\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output boolean\n */\nexport function fIsSame(\n  startDate: DatePickerFormat,\n  endDate: DatePickerFormat,\n  unitToCompare?: OpUnitType\n): boolean {\n  if (!isValidDate(startDate) || !isValidDate(endDate)) {\n    return false;\n  }\n\n  return dayjs(startDate).isSame(endDate, unitToCompare ?? 'year');\n}\n\n/**\n * @output\n * Same day: 26 Apr 2024\n * Same month: 25 - 26 Apr 2024\n * Same month: 25 - 26 Apr 2024\n * Same year: 25 Apr - 26 May 2024\n */\nexport function fDateRangeShortLabel(\n  startDate: DatePickerFormat,\n  endDate: DatePickerFormat,\n  initial?: boolean\n): string {\n  if (\n    !isValidDate(startDate) ||\n    !isValidDate(endDate) ||\n    fIsAfter(startDate, endDate)\n  ) {\n    return 'Invalid date';\n  }\n\n  let label = `${fDate(startDate)} - ${fDate(endDate)}`;\n\n  if (initial) {\n    return label;\n  }\n\n  const isSameYear = fIsSame(startDate, endDate, 'year');\n  const isSameMonth = fIsSame(startDate, endDate, 'month');\n  const isSameDay = fIsSame(startDate, endDate, 'day');\n\n  if (isSameYear && !isSameMonth) {\n    label = `${fDate(startDate, 'DD MMM')} - ${fDate(endDate)}`;\n  } else if (isSameYear && isSameMonth && !isSameDay) {\n    label = `${fDate(startDate, 'DD')} - ${fDate(endDate)}`;\n  } else if (isSameYear && isSameMonth && isSameDay) {\n    label = `${fDate(endDate)}`;\n  }\n\n  return label;\n}\n\n// ----------------------------------------------------------------------\n\n/**\n * @output 2024-05-28T05:55:31+00:00\n */\nexport interface DurationProps {\n  years?: number;\n  months?: number;\n  days?: number;\n  hours?: number;\n  minutes?: number;\n  seconds?: number;\n  milliseconds?: number;\n}\n\nexport function fAdd({\n  years = 0,\n  months = 0,\n  days = 0,\n  hours = 0,\n  minutes = 0,\n  seconds = 0,\n  milliseconds = 0,\n}: DurationProps) {\n  const result = dayjs()\n    .add(\n      dayjs.duration({\n        years,\n        months,\n        days,\n        hours,\n        minutes,\n        seconds,\n        milliseconds,\n      })\n    )\n    .format();\n\n  return result;\n}\n\n/**\n * @output 2024-05-28T05:55:31+00:00\n */\nexport function fSub({\n  years = 0,\n  months = 0,\n  days = 0,\n  hours = 0,\n  minutes = 0,\n  seconds = 0,\n  milliseconds = 0,\n}: DurationProps) {\n  const result = dayjs()\n    .subtract(\n      dayjs.duration({\n        years,\n        months,\n        days,\n        hours,\n        minutes,\n        seconds,\n        milliseconds,\n      })\n    )\n    .format();\n\n  return result;\n}\n", "type EmptyValue<T> = T extends number\n  ? 0\n  : T extends string\n    ? null\n    : T extends boolean\n      ? null\n      : T extends Date\n        ? null\n        : T extends object\n          ? null\n          : null;\n\ntype EmptyObject<T extends object> = {\n  [K in keyof T]: EmptyValue<T[K]>;\n};\n\nexport function getEmptyObject<T extends object>(\n  data: T,\n  defaultValues: Partial<T> = {}\n): EmptyObject<T> & Partial<T> {\n  const obj = {} as Record<string, unknown>;\n\n  for (const key of Object.keys(data) as Array<keyof T>) {\n    const value = data[key];\n    const type = typeof value;\n\n    if (type === 'number') {\n      obj[key as string] = 0;\n    } else if (type === 'string' || type === 'boolean') {\n      obj[key as string] = null;\n    } else if (value instanceof Date) {\n      obj[key as string] = null;\n    } else {\n      obj[key as string] = null;\n    }\n  }\n\n  return { ...obj, ...defaultValues } as EmptyObject<T> & Partial<T>;\n}\n", "import { useRef, useMemo } from 'react';\n\n/**\n * Hook to maintain stable row count for data grids during loading states.\n * Prevents pagination jumping by preserving the last known total count.\n *\n * @param currentTotal - Current total from API response\n * @returns Stable row count that persists during loading\n */\nexport function useStableRowCount(currentTotal: number | undefined): number {\n  const rowCountRef = useRef(currentTotal || 0);\n\n  const stableRowCount = useMemo(() => {\n    if (currentTotal !== undefined) {\n      rowCountRef.current = currentTotal;\n    }\n\n    return rowCountRef.current;\n  }, [currentTotal]);\n\n  return stableRowCount;\n}\n"],
  "mappings": ";AAwBA,SAAS,eAAuB;AAC9B,MAAI,OAAO,WAAW,eAAe,OAAO,YAAY;AACtD,WAAO,OAAO,WAAW;AAAA,EAC3B;AAGA,SAAO,uCAAuC,QAAQ,SAAS,OAAK;AAClE,UAAM,IAAK,KAAK,OAAO,IAAI,KAAM;AACjC,UAAM,IAAI,MAAM,MAAM,IAAK,IAAI,IAAO;AAEtC,WAAO,EAAE,SAAS,EAAE;AAAA,EACtB,CAAC;AACH;AA4CO,SAAS,sBAAsB,QAAyB;AAC7D,QAAM,OAAO,aAAa;AAE1B,SAAO,SAAS,GAAG,MAAM,IAAI,IAAI,KAAK;AACxC;;;ACjEO,IAAM,kBAAN,MAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqB3B,aAAa,QAA8B;AACzC,QAAI,UAAU,OAAO,SAAS,KAAK;AACjC,aAAO,WAAW,MAAM,qBAAqB;AAAA,IAC/C,WAAW,UAAU,KAAK;AACxB,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,cAAc,QAAwB;AACpC,UAAM,SAAiC;AAAA,MACrC,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAEA,WAAO,OAAO,MAAM,KAAK,cAAc,MAAM;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgDA,eACE,OACA,QACA,eACU;AAEV,QAAI,UAAU,QAAQ,UAAU,QAAW;AACzC,aAAO,OAAO,OAAO,IAAI,MAAM,2BAA2B,GAAG;AAAA,QAC3D,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW;AAAA,QACX;AAAA,MACF,CAAa;AAAA,IACf;AAGA,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO,OAAO,OAAO,IAAI,MAAM,KAAK,GAAG;AAAA,QACrC,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW;AAAA,QACX;AAAA,MACF,CAAa;AAAA,IACf;AAEA,UAAM,MAAM;AAGZ,QAAI,IAAI,QAAQ,IAAI,SAAS,IAAI,QAAQ;AACvC,aAAO,OAAO;AAAA,QACZ,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,IAAI,WAAW,eAAe;AAAA,QACzE;AAAA,UACE,MAAM,IAAI;AAAA,UACV,OAAO,IAAI;AAAA,UACX,QAAQ,IAAI;AAAA,UACZ,SAAS,IAAI,WAAW;AAAA,UACxB,QAAQ,IAAI;AAAA,UACZ,WAAW,IAAI,aAAa;AAAA,UAC5B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,IAAI,SAAS,gBAAgB,IAAI,WAAW;AAC9C,aAAO,OAAO,OAAO,IAAI,MAAM,IAAI,WAAW,qBAAqB,GAAG;AAAA,QACpE,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW;AAAA,QACX;AAAA,MACF,CAAa;AAAA,IACf;AAEA,QAAI,IAAI,SAAS,SAAS,SAAS,GAAG;AACpC,aAAO,OAAO,OAAO,IAAI,MAAM,IAAI,OAAO,GAAG;AAAA,QAC3C,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW;AAAA,QACX;AAAA,MACF,CAAa;AAAA,IACf;AAEA,QAAI,IAAI,SAAS,SAAS,SAAS,GAAG;AACpC,aAAO,OAAO,OAAO,IAAI,MAAM,IAAI,WAAW,wBAAwB,GAAG;AAAA,QACvE,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW;AAAA,QACX;AAAA,MACF,CAAa;AAAA,IACf;AAEA,WAAO,OAAO;AAAA,MACZ,IAAI,MAAM,IAAI,WAAW,2BAA2B;AAAA,MACpD;AAAA,QACE,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW;AAAA,QACX;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;;;ACpKO,IAAM,qBAAN,MAAyB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKb,sBAA4C,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAM7C,uBAA8C,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAM/C,oBAAwC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6B1D,sBAAsB,aAA6C;AACjE,SAAK,oBAAoB,KAAK,WAAW;AAEzC,WAAO,MAAM;AACX,YAAM,QAAQ,KAAK,oBAAoB,QAAQ,WAAW;AAE1D,UAAI,QAAQ,GAAI,MAAK,oBAAoB,OAAO,OAAO,CAAC;AAAA,IAC1D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkCA,uBAAuB,aAA8C;AACnE,SAAK,qBAAqB,KAAK,WAAW;AAE1C,WAAO,MAAM;AACX,YAAM,QAAQ,KAAK,qBAAqB,QAAQ,WAAW;AAE3D,UAAI,QAAQ,GAAI,MAAK,qBAAqB,OAAO,OAAO,CAAC;AAAA,IAC3D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuCA,oBAAoB,aAA2C;AAC7D,SAAK,kBAAkB,KAAK,WAAW;AAEvC,WAAO,MAAM;AACX,YAAM,QAAQ,KAAK,kBAAkB,QAAQ,WAAW;AAExD,UAAI,QAAQ,GAAI,MAAK,kBAAkB,OAAO,OAAO,CAAC;AAAA,IACxD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAM,yBACJ,QACwB;AACxB,QAAI,iBAAiB,EAAE,GAAG,OAAO;AAEjC,eAAW,eAAe,KAAK,qBAAqB;AAClD,uBAAiB,MAAM,YAAY,cAAc;AAAA,IACnD;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,MAAM,0BACJ,UACyB;AACzB,QAAI,mBAAmB;AAEvB,eAAW,eAAe,KAAK,sBAAsB;AACnD,yBAAmB,MAAM,YAAY,gBAAgB;AAAA,IACvD;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAyBA,MAAM,uBAAuB,OAAiC;AAC5D,QAAI,gBAAgB;AAEpB,eAAW,eAAe,KAAK,mBAAmB;AAChD,UAAI;AACF,wBAAgB,MAAM,YAAY,aAAa;AAAA,MACjD,SAAS,GAAG;AACV,wBAAgB;AAAA,MAClB;AAAA,IACF;AAEA,UAAM;AAAA,EACR;AACF;;;AC9QO,IAAM,iBAAN,MAAqB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlB,iBAA+C,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA,EAMvD,iBAAsC,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBtD,IAAI,KAAa,YAA6B,eAA6B;AAEzE,SAAK,OAAO,GAAG;AACf,SAAK,eAAe,IAAI,KAAK,UAAU;AACvC,SAAK,eAAe,IAAI,KAAK,aAAa;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,OAAO,KAAmB;AACxB,SAAK,eAAe,OAAO,GAAG;AAC9B,SAAK,eAAe,OAAO,GAAG;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,OAAO,KAAmB;AACxB,UAAM,aAAa,KAAK,eAAe,IAAI,GAAG;AAE9C,QAAI,YAAY;AACd,iBAAW,MAAM;AACjB,WAAK,eAAe,OAAO,GAAG;AAC9B,WAAK,eAAe,OAAO,GAAG;AAAA,IAChC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,YAAkB;AAChB,SAAK,eAAe,QAAQ,gBAAc,WAAW,MAAM,CAAC;AAC5D,SAAK,eAAe,MAAM;AAC1B,SAAK,eAAe,MAAM;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,IAAI,KAAsB;AACxB,WAAO,KAAK,eAAe,IAAI,GAAG;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,iBAAiB,KAAiC;AAChD,WAAO,KAAK,eAAe,IAAI,GAAG;AAAA,EACpC;AACF;;;ACzIO,IAAM,eAAN,MAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiExB,MAAM,aACJ,IACA,SACA,OACA,QACY;AACZ,QAAI;AAEF,UAAI,QAAQ,SAAS;AACnB,cAAM,IAAI,MAAM,OAAO,UAAU,iBAAiB;AAAA,MACpD;AAEA,aAAO,MAAM,GAAG;AAAA,IAClB,SAAS,OAAgB;AACvB,YAAM,MAAM;AAGZ,UAAI,IAAI,SAAS,gBAAgB,QAAQ,SAAS;AAChD,cAAM;AAAA,MACR;AAGA,UAAI,IAAI,SAAS,sBAAsB,IAAI,WAAW,KAAK;AACzD,cAAM;AAAA,MACR;AAEA,UAAI,YAAY,EAAG,OAAM;AAGzB,YAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAC3C,cAAM,YAAY,WAAW,SAAS,KAAK;AAE3C,YAAI,QAAQ;AACV,iBAAO;AAAA,YACL;AAAA,YACA,MAAM;AACJ,2BAAa,SAAS;AACtB,qBAAO,IAAI,MAAM,OAAO,UAAU,iBAAiB,CAAC;AAAA,YACtD;AAAA,YACA,EAAE,MAAM,KAAK;AAAA,UACf;AAAA,QACF;AAAA,MACF,CAAC;AAED,aAAO,KAAK,aAAa,IAAI,UAAU,GAAG,QAAQ,GAAG,MAAM;AAAA,IAC7D;AAAA,EACF;AACF;;;AC9GO,IAAM,gBAAN,MAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuDzB,qBACE,SACiB;AACjB,UAAM,aAAa,IAAI,gBAAgB;AAEvC,eAAW,UAAU,SAAS;AAC5B,UAAI,QAAQ;AACV,YAAI,OAAO,SAAS;AAClB,qBAAW,MAAM,OAAO,MAAM;AAC9B;AAAA,QACF;AAEA,eAAO;AAAA,UACL;AAAA,UACA,MAAM;AACJ,uBAAW,MAAM,OAAO,MAAM;AAAA,UAChC;AAAA,UACA,EAAE,MAAM,KAAK;AAAA,QACf;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA4DA,oBAAoB,SAAkC;AACpD,UAAM,aAAa,IAAI,gBAAgB;AAEvC,UAAM,YAAY,WAAW,MAAM;AACjC,iBAAW,MAAM,yBAAyB,OAAO,IAAI;AAAA,IACvD,GAAG,OAAO;AAGV,eAAW,OAAO;AAAA,MAChB;AAAA,MACA,MAAM;AACJ,qBAAa,SAAS;AAAA,MACxB;AAAA,MACA,EAAE,MAAM,KAAK;AAAA,IACf;AAEA,WAAO;AAAA,EACT;AACF;;;AC9IO,IAAM,iBAAN,MAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqD1B,MAAM,cAAc,UAA2C;AAC7D,UAAM,cAAc,SAAS,QAAQ,IAAI,cAAc;AAEvD,QAAI,aAAa,SAAS,kBAAkB,GAAG;AAC7C,aAAO,SAAS,KAAK;AAAA,IACvB,WAAW,aAAa,SAAS,OAAO,GAAG;AACzC,aAAO,SAAS,KAAK;AAAA,IACvB,WAAW,aAAa,SAAS,0BAA0B,GAAG;AAC5D,aAAO,SAAS,KAAK;AAAA,IACvB,OAAO;AAEL,YAAM,OAAO,MAAM,SAAS,KAAK;AAEjC,UAAI;AACF,eAAO,KAAK,MAAM,IAAI;AAAA,MACxB,QAAQ;AACN,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AACF;;;ACxFO,IAAM,aAAN,MAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0EtB,SAAS,SAAiB,UAAkB,QAA8B;AACxE,UAAM,MAAM,IAAI,IAAI,UAAU,OAAO;AAErC,QAAI,QAAQ;AACV,aAAO,KAAK,MAAM,EAAE,QAAQ,SAAO;AACjC,cAAM,QAAQ,OAAO,GAAG;AAExB,YAAI,UAAU,UAAa,UAAU,MAAM;AACzC,cAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,kBAAM,QAAQ,OAAK,IAAI,aAAa,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC;AAAA,UAC5D,OAAO;AACL,gBAAI,aAAa,OAAO,KAAK,OAAO,KAAK,CAAC;AAAA,UAC5C;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WAAO,IAAI,SAAS;AAAA,EACtB;AACF;;;AC3BO,IAAM,YAAN,MAAgB;AAAA,EACJ;AAAA,EACA;AAAA,EACA,qBACf,IAAI,mBAAmB;AAAA,EACR,gBAA+B,IAAI,cAAc;AAAA,EACjD,kBAAmC,IAAI,gBAAgB;AAAA,EACvD,iBAAiC,IAAI,eAAe;AAAA,EACpD,aAAyB,IAAI,WAAW;AAAA,EACxC,eAA6B,IAAI,aAAa;AAAA,EAC9C,iBAAiC,IAAI,eAAe;AAAA,EAC7D,YAA2B;AAAA,EAC3B,sBAA8B;AAAA,EAC9B,uBAAgC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOxC,YAAY,UAAkB,IAAI,iBAAyB,KAAO;AAChE,SAAK,UAAU;AACf,SAAK,iBAAiB;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,uBAAuB,QAAsB;AAC3C,SAAK,sBAAsB;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,wBAAwB,SAAwB;AAC9C,SAAK,uBAAuB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,sBAAsB,aAA6C;AACjE,WAAO,KAAK,mBAAmB,sBAAsB,WAAW;AAAA,EAClE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,uBAAuB,aAA8C;AACnE,WAAO,KAAK,mBAAmB,uBAAuB,WAAW;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,oBAAoB,aAA2C;AAC7D,WAAO,KAAK,mBAAmB,oBAAoB,WAAW;AAAA,EAChE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,aAAa,OAA4B;AACvC,SAAK,YAAY;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,eAA8B;AAC5B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAc,KAAmB;AAC/B,SAAK,eAAe,OAAO,GAAG;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,oBAA0B;AACxB,SAAK,eAAe,UAAU;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,MAAM,QACJ,UACA,SAAwB,CAAC,GACU;AAEnC,UAAM,gBACJ,OAAO,kBACN,CAAC,OAAO,qBAAqB,KAAK,uBAC/B,sBAAsB,KAAK,mBAAmB,IAC9C;AAEN,UAAM,aAAa,GAAG,OAAO,UAAU,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,CAAC;AAGtE,UAAM,mBAAmB,IAAI,gBAAgB;AAE7C,QAAI;AAEF,YAAM,UAA0C;AAAA,QAC9C,OAAO;AAAA,QACP,OAAO,aAAa;AAAA,QACpB,iBAAiB;AAAA,MACnB;AAGA,YAAM,UAAU,OAAO,WAAW,KAAK;AACvC,YAAM,oBAAoB,KAAK,cAAc,oBAAoB,OAAO;AAExE,cAAQ,KAAK,kBAAkB,MAAM;AAGrC,YAAM,qBACJ,KAAK,cAAc,qBAAqB,OAAO;AAGjD,UAAI,eAAe;AACjB,aAAK,eAAe,IAAI,YAAY,kBAAkB,aAAa;AAAA,MACrE;AAGA,YAAM,cACJ,MAAM,KAAK,mBAAmB,yBAAyB;AAAA,QACrD,GAAG;AAAA,QACH,QAAQ,mBAAmB;AAAA,QAC3B;AAAA,MACF,CAAC;AAGH,YAAM,MAAM,KAAK,WAAW;AAAA,QAC1B,KAAK;AAAA,QACL;AAAA,QACA,YAAY;AAAA,MACd;AAGA,YAAM,UAAU,IAAI,QAAQ,YAAY,OAAO;AAG/C,UAAI,eAAe;AACjB,gBAAQ,IAAI,oBAAoB,aAAa;AAC7C,gBAAQ,IAAI,gBAAgB,aAAa;AAAA,MAC3C;AAGA,UAAI,KAAK,aAAa,CAAC,YAAY,iBAAiB;AAClD,gBAAQ,IAAI,iBAAiB,UAAU,KAAK,SAAS,EAAE;AAAA,MACzD;AAIA,UAAI,YAAyC,YAAY;AAKzD,UACE,YAAY,QACZ,OAAO,YAAY,SAAS,YAC5B,EAAE,YAAY,gBAAgB,aAC9B,EAAE,YAAY,gBAAgB,SAC9B,EAAE,YAAY,gBAAgB,gBAC9B,EAAE,YAAY,gBAAgB,oBAC9B,EAAE,YAAY,gBAAgB,iBAC9B;AACA,gBAAQ,IAAI,gBAAgB,kBAAkB;AAC9C,oBAAY,KAAK,UAAU,YAAY,IAAI;AAAA,MAC7C;AAEA,kBAAY,UAAU;AAGtB,YAAM,eAAe,YAA+C;AAClE,YAAI;AACF,gBAAM,WAAW,MAAM,MAAM,KAAK;AAAA,YAChC,GAAG;AAAA,YACH,MAAM;AAAA,YACN,QAAQ,mBAAmB;AAAA,UAC7B,CAAgB;AAGhB,gBAAM,eACJ,MAAM,KAAK,eAAe,cAAc,QAAQ;AAGlD,cAAI,CAAC,SAAS,IAAI;AAEhB,kBAAM,YAAY;AAElB,kBAAM,QAAkB,OAAO;AAAA,cAC7B,IAAI;AAAA,gBACF,UAAU,SACR,QAAQ,SAAS,MAAM,KAAK,SAAS,UAAU;AAAA,cACnD;AAAA,cACA;AAAA,gBACE,MACE,UAAU,QACV,KAAK,gBAAgB,aAAa,SAAS,MAAM;AAAA,gBACnD,OACE,UAAU,SACV,KAAK,gBAAgB,cAAc,SAAS,MAAM;AAAA,gBACpD,QAAQ,SAAS;AAAA,gBACjB,SAAS,UAAU,WAAW;AAAA,gBAC9B,QAAQ,UAAU;AAAA,gBAClB,WAAW;AAAA,gBACX,QAAQ;AAAA,cACV;AAAA,YACF;AAGA,gBAAI,YAAY,gBAAgB,OAAO;AACrC,oBAAM;AAAA,YACR,OAAO;AAEL,qBAAO,MAAM,KAAK,mBAAmB,0BAA0B;AAAA,gBAC7D;AAAA,cACF,CAA6B;AAAA,YAC/B;AAAA,UACF;AAGA,gBAAM,cAA8B;AAAA,YAClC,MAAM;AAAA,UACR;AAGA,iBAAO,MAAM,KAAK,mBAAmB;AAAA,YACnC;AAAA,UACF;AAAA,QACF,SAAS,OAAgB;AAEvB,cAAK,MAAgB,SAAS,cAAc;AAC1C,kBAAM,aAAa,OAAO;AAAA,cACxB,IAAI,MAAO,MAAgB,WAAW,iBAAiB;AAAA,cACvD;AAAA,gBACE,MAAM;AAAA,gBACN,OAAO;AAAA,gBACP,QAAQ;AAAA,gBACR,SAAS;AAAA,gBACT,WAAW;AAAA,gBACX,QAAQ;AAAA,cACV;AAAA,YACF;AAGA,gBAAI,YAAY,gBAAgB,OAAO;AACrC,oBAAM;AAAA,YACR,OAAO;AAEL,qBAAO,MAAM,KAAK,mBAAmB,0BAA0B;AAAA,gBAC7D,OAAO;AAAA,cACT,CAA6B;AAAA,YAC/B;AAAA,UACF;AAEA,gBAAM;AAAA,QACR;AAAA,MACF;AAGA,UAAI,YAAY,WAAW,YAAY,UAAU,GAAG;AAClD,eAAO,MAAM,KAAK,aAAa;AAAA,UAC7B;AAAA,UACA,YAAY;AAAA,UACZ,YAAY,cAAc;AAAA,UAC1B,mBAAmB;AAAA,QACrB;AAAA,MACF;AAEA,aAAO,MAAM,aAAa;AAAA,IAC5B,SAAS,OAAO;AAEd,YAAM,WAAqB,KAAK,gBAAgB;AAAA,QAC9C;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAGA,UAAI,OAAO,gBAAgB,OAAO;AAChC,cAAM,KAAK,mBAAmB,uBAAuB,QAAQ;AAG7D,cAAM;AAAA,MACR,OAAO;AAEL,eAAO;AAAA,UACL,OAAO;AAAA,QACT;AAAA,MACF;AAAA,IACF,UAAE;AAEA,WAAK,eAAe,OAAO,UAAU;AAAA,IACvC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,IACE,UACA,QACmC;AACnC,WAAO,KAAK,QAAW,UAAU,EAAE,GAAG,QAAQ,QAAQ,MAAM,CAAC;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,KAOE,UACA,MACA,QACmC;AACnC,WAAO,KAAK,QAAW,UAAU,EAAE,GAAG,QAAQ,QAAQ,QAAQ,MAAM,KAAK,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,IAOE,UACA,MACA,QACmC;AACnC,WAAO,KAAK,QAAW,UAAU,EAAE,GAAG,QAAQ,QAAQ,OAAO,MAAM,KAAK,CAAC;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAOE,UACA,MACA,QACmC;AACnC,WAAO,KAAK,QAAW,UAAU;AAAA,MAC/B,GAAG;AAAA,MACH,QAAQ;AAAA,MACR,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,OACE,UACA,QACmC;AACnC,WAAO,KAAK,QAAW,UAAU,EAAE,GAAG,QAAQ,QAAQ,SAAS,CAAC;AAAA,EAClE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA8BA,OACE,KACA,MACA,QAC0D;AAE1D,UAAM,aAAa,EAAE,GAAG,MAAM,GAAG,KAAK,YAAY;AAElD,WAAO,KAAK,QAAkC,KAAK;AAAA,MACjD,GAAG;AAAA,MACH,QAAQ;AAAA,MACR,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AACF;;;ACzkBA,IAAI,kBAAoC;AA2DjC,SAAS,gBAAgB,SAA0B,CAAC,GAAc;AACvE,QAAM;AAAA,IACJ,UAAU;AAAA,IACV,UAAU;AAAA,IACV,sBAAsB;AAAA,IACtB,uBAAuB;AAAA,IACvB,sBAAsB,CAAC;AAAA,IACvB,uBAAuB,CAAC;AAAA,IACxB,oBAAoB,CAAC;AAAA,EACvB,IAAI;AAEJ,QAAM,SAAS,IAAI,UAAU,SAAS,OAAO;AAE7C,SAAO,sBAAsB,CAAAA,YAAU;AACrC,UAAM,QAAQ,aAAa,QAAQ,cAAc;AAEjD,QAAI,SAAS,CAACA,QAAO,iBAAiB;AACpC,MAAAA,QAAO,UAAU;AAAA,QACf,GAAGA,QAAO;AAAA,QACV,eAAe,UAAU,KAAK;AAAA,MAChC;AAAA,IACF;AAEA,WAAOA;AAAA,EACT,CAAC;AAGD,SAAO,uBAAuB,mBAAmB;AACjD,SAAO,wBAAwB,oBAAoB;AAQnD,sBAAoB,QAAQ,iBAAe;AACzC,WAAO,sBAAsB,WAAW;AAAA,EAC1C,CAAC;AAED,uBAAqB,QAAQ,iBAAe;AAC1C,WAAO,uBAAuB,WAAW;AAAA,EAC3C,CAAC;AAED,oBAAkB,QAAQ,iBAAe;AACvC,WAAO,oBAAoB,WAAW;AAAA,EACxC,CAAC;AAED,SAAO;AACT;AAwDO,SAAS,mBAAmB,QAAqC;AACtE,MAAI,CAAC,iBAAiB;AACpB,sBAAkB,gBAAgB,MAAM;AAAA,EAC1C;AAEA,SAAO;AACT;AAkCO,SAAS,mBAAmB,QAAyB;AAC1D,oBAAkB;AACpB;AAsCO,SAAS,uBAA6B;AAC3C,oBAAkB;AACpB;;;AC9TO,IAAM,cAAN,MAAM,aAAY;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EAER,cAAc;AACZ,SAAK,kBAAkB,IAAI,gBAAgB;AAC3C,SAAK,gBAAgB,IAAI,QAAQ,aAAW;AAC1C,WAAK,gBAAgB;AAAA,IACvB,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,SAAsB;AACxB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,OAAO,QAAuB;AAC5B,SAAK,gBAAgB,MAAM,MAAM;AACjC,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,IAAI,cAAuB;AACzB,WAAO,KAAK,gBAAgB,OAAO;AAAA,EACrC;AAAA,EAEA,mBAAyB;AACvB,QAAI,KAAK,aAAa;AACpB,YAAM,IAAI,MAAM,mBAAmB;AAAA,IACrC;AAAA,EACF;AAAA,EAEA,OAAO,SAAoE;AACzE,UAAM,QAAQ,IAAI,aAAY;AAE9B,WAAO;AAAA,MACL;AAAA,MACA,QAAQ,CAAC,WAAoB,MAAM,OAAO,MAAM;AAAA,IAClD;AAAA,EACF;AACF;;;ACvCA,SAAS,mBAAmB;AAiBrB,SAAS,oBAAoB,OAAwB;AAC1D,QAAM,gBAAgB;AAAA,IACpB,CAAC,UAAiC;AAChC,UAAI,CAAC,OAAO,UAAU,CAAC,MAAM,OAAO,KAAK,EAAG,QAAO;AAEnD,YAAM,aAAa,MAAM,OAAO,KAAK;AAErC,UAAI,OAAO,eAAe,SAAU,QAAO;AAC3C,UAAI,MAAM,QAAQ,UAAU,EAAG,QAAO,WAAW,CAAC;AAClD,UAAI,OAAO,eAAe,YAAY,aAAa,YAAY;AAC7D,eAAO,WAAW;AAAA,MACpB;AAEA,aAAO;AAAA,IACT;AAAA,IACA,CAAC,KAAK;AAAA,EACR;AAEA,QAAM,gBAAgB;AAAA,IACpB,CAAC,UAA2B;AAC1B,aAAO,CAAC,CAAC,cAAc,KAAK;AAAA,IAC9B;AAAA,IACA,CAAC,aAAa;AAAA,EAChB;AAEA,QAAM,eAAe,YAAY,MAA8B;AAC7D,QAAI,CAAC,OAAO,OAAQ,QAAO,CAAC;AAE5B,UAAM,SAAiC,CAAC;AAExC,WAAO,QAAQ,MAAM,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AACrD,UAAI,OAAO,UAAU,UAAU;AAC7B,eAAO,GAAG,IAAI;AAAA,MAChB,WAAW,MAAM,QAAQ,KAAK,GAAG;AAC/B,eAAO,GAAG,IAAI,MAAM,KAAK,IAAI;AAAA,MAC/B,WAAW,OAAO,UAAU,YAAY,SAAS,aAAa,OAAO;AACnE,eAAO,GAAG,IAAI,MAAM;AAAA,MACtB;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,KAAK,CAAC;AAEV,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,WAAW,OAAO;AAAA,EACpB;AACF;;;AC5DoB;AADb,IAAM,iBAAiB,CAAC,EAAE,UAAU,KAAK,MAA2B;AACzE,MAAI,CAAC,KAAM,QAAO,gCAAE;AAEpB,SAAO,gCAAG,UAAS;AACrB;;;ACTA,SAAS,cAAc;AASrB,gBAAAC,YAAA;AANK,IAAM,eAAsC,CAAC;AAAA,EAClD,WAAW;AAAA,EACX,UAAU;AAAA,EACV;AAAA,EACA,GAAG;AACL,MACE,gBAAAA,KAAC,UAAO,SAAkB,IAAI,EAAE,OAAO,QAAQ,GAAG,GAAG,GAAI,GAAG,MACzD,UACH;;;ACXF,SAAS,UAAAC,eAAc;AA4EnB,gBAAAC,YAAA;AAdG,IAAM,cAAc,CAAC;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAwB;AACtB,QAAM,UAAU,MAAM;AACpB,gBAAY;AACZ,QAAI,YAAY,MAAM;AACpB,mBAAa,WAAW,QAAQ;AAAA,IAClC;AAAA,EACF;AAEA,SACE,gBAAAA;AAAA,IAACD;AAAA,IAAA;AAAA,MACC,SAAQ;AAAA,MACR;AAAA,MACA,UAAU;AAAA,MACV;AAAA,MACD;AAAA;AAAA,EAED;AAEJ;;;ACtFA,SAAS,iBAA+B;AActC,gBAAAE,YAAA;AALK,IAAM,kBAAkB,CAAC;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AACF,MACE,gBAAAA,KAAC,aAAU,WAAsB,IAAI,EAAE,GAAG,GAAG,GAC1C,UACH;;;AChBF,OAAO,mBAAmB;AAC1B,SAAS,qBAAqB;AAE9B,SAAS,aAAa;AA4GG,gBAAAC,YAAA;AAvBlB,IAAM,eAAe,CAAC;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAyB;AACvB,SACE,gBAAAA;AAAA,IAAC;AAAA;AAAA,MACC,MAAK;AAAA,MACL,SAAQ;AAAA,MACR,SAAS;AAAA,MACT,UAAU,CAAC;AAAA,MACX,eAAa;AAAA,MACb,OAAM;AAAA,MACN,IAAI;AAAA,QACF,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,GAAG;AAAA,MACL;AAAA,MACA,WACE,gBAAAA,KAAC,SAAM,OAAM,SAAQ,SAAQ,YAC1B,iBAAO,OAAO,gBAAAA,KAAC,iBAAc,OAAM,MAAK,QAAO,MAAK,IAAI,QAAQ,GACnE;AAAA,MAGD,iBAAO,KAAK,MAAM,MAAM,CAAC,QAAQ,WAAW;AAAA;AAAA,EAC/C;AAEJ;;;ACtHA,OAAO,UAAU;AACjB,SAAS,YAAY;AAoBf,gBAAAC,YAAA;AAjBC,IAAM,aAAa;AAAA,EACxB,CAAC;AAAA,IACC;AAAA,IACA;AAAA,IACA;AAAA,EACF,MAIM;AACJ,UAAM,WACJ,OAAO,UAAU,QACjB,OAAO,UAAU,UACjB,OAAO,UAAU;AACnB,UAAM,QAAQ,GAAG,SAAS,QAAQ,MAAM,EAAE,CAAC,KAAK,OAAO,KAAK;AAE5D,WACE,gBAAAA;AAAA,MAAC;AAAA;AAAA,QAEC;AAAA,QACA,SAAS,WAAW,WAAW;AAAA,QAC/B,MAAK;AAAA,QACL,UAAU,WAAW,WAAW;AAAA;AAAA,MAJ3B;AAAA,IAKP;AAAA,EAEJ;AACF;AAEA,WAAW,cAAc;;;AChCzB,SAAS,MAAM,aAAa,YAAY,WAAW;AACnD,SAAS,QAAAC,OAAM,eAAe;AA+BtB,gBAAAC,MAWA,YAXA;AAtBD,IAAM,wBAAwBC;AAAA,EACnC,CACE,UACG;AACH,UAAM,EAAE,gBAAgB,uBAAuB,IAAI;AAGnD,UAAM,iBAAiB,QAAQ,MAAM;AACnC,UAAI,CAAC,uBAAwB,QAAO,CAAC;AAErC,YAAM,WAAuC,CAAC;AAE9C,iBAAW,OAAO,OAAO,KAAK,cAAc,GAAG;AAC7C,iBAAS,GAAG,IAAI,MAAM,uBAAuB,GAAyB;AAAA,MACxE;AAEA,aAAO;AAAA,IACT,GAAG,CAAC,wBAAwB,cAAc,CAAC;AAG3C,UAAM,WAAW,QAAQ,MAAM;AAC7B,aAAO,OAAO,QAAQ,cAAc,EAAE,IAAI,CAAC,CAAC,KAAK,MAAM,MACrD,gBAAAD;AAAA,QAAC;AAAA;AAAA,UAEC,UAAU;AAAA,UACV;AAAA,UACA,UAAU,eAAe,GAAG;AAAA;AAAA,QAHvB;AAAA,MAIP,CACD;AAAA,IACH,GAAG,CAAC,gBAAgB,cAAc,CAAC;AAEnC,WACE,gBAAAA,KAAC,QAAK,IAAI,EAAE,IAAI,EAAE,GAChB,+BAAC,eACC;AAAA,sBAAAA,KAAC,cAAW,SAAQ,MAAK,cAAY,MAAC,4BAEtC;AAAA,MACA,gBAAAA,KAAC,OAAI,SAAQ,QAAO,KAAK,GAAG,UAAS,QAClC,oBACH;AAAA,OACF,GACF;AAAA,EAEJ;AACF;AAEA,sBAAsB,cAAc;;;ACxDpC,OAAO,sBAAsB;AAE7B;AAAA,EACE,OAAAE;AAAA,EACA,QAAAC;AAAA,EACA,eAAAC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,cAAAC;AAAA,EACA;AAAA,OACK;AAuIO,SAiBoD,YAAAC,WAjBpD,OAAAC,MAQF,QAAAC,aARE;AArCP,IAAM,gBAAgB,CAAC;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAA0B;AACxB,QAAM,QAAQ,SAAS;AAEvB,SACE,gBAAAA;AAAA,IAACL;AAAA,IAAA;AAAA,MACC,IAAI;AAAA,QACF,UAAU;AAAA,QACV,cAAc;AAAA,QACd,IAAI;AAAA,QACJ,GAAG;AAAA,MACL;AAAA,MAEA;AAAA,wBAAAI;AAAA,UAAC;AAAA;AAAA,YACC,IAAI;AAAA,cACF,SAAS;AAAA,cACT,UAAU;AAAA,cACV,GAAG;AAAA,cACH,yBAAyB;AAAA,gBACvB,QAAQ;AAAA,gBACR,WAAW;AAAA,cACb;AAAA,cACA,YAAY;AAAA,YACd;AAAA,YACA,OACE,gBAAAC,MAACN,MAAA,EAAI,IAAI,EAAE,SAAS,QAAQ,YAAY,UAAU,KAAK,IAAI,GACxD;AAAA,qBACC,OAEA,gBAAAK;AAAA,gBAAC;AAAA;AAAA,kBACC,IAAI;AAAA,oBACF,QAAQ;AAAA,oBACR,OAAO,MAAM,QAAQ,QAAQ;AAAA,oBAC7B,GAAG;AAAA,kBACL;AAAA;AAAA,cACF;AAAA,cAEF,gBAAAC;AAAA,gBAACH;AAAA,gBAAA;AAAA,kBACC,SAAQ;AAAA,kBACR,IAAI;AAAA,oBACF,YAAY;AAAA,oBACZ,OAAO,MAAM,QAAQ,QAAQ;AAAA,oBAC7B,GAAG;AAAA,kBACL;AAAA,kBAEC;AAAA,4BAAQ,QAAQ;AAAA,oBAAU;AAAA,oBAC1B,YAAY,IAAI,cAAc,cAAc,CAAC,MAAM,gBAAAE,KAAAD,WAAA,EAAE;AAAA;AAAA;AAAA,cACxD;AAAA,eACF;AAAA;AAAA,QAEH;AAAA,QACD,gBAAAC,KAAC,WAAQ;AAAA,QACT,gBAAAA,KAACH,cAAA,EAAY,IAAI,EAAE,IAAI,EAAE,GACvB,0BAAAG,KAAC,QAAK,WAAS,MAAC,SAAS,GACtB,UACH,GACF;AAAA;AAAA;AAAA,EACF;AAEJ;;;AC/KA,SAAS,OAAAE,MAAK,cAAAC,mBAAkB;AAmB1B,gBAAAC,YAAA;AAhBC,IAAM,SAAmB,MAAM;AACpC,QAAM,eAAc,oBAAI,KAAK,GAAE,YAAY;AAE3C,SACE,gBAAAA;AAAA,IAACF;AAAA,IAAA;AAAA,MACC,WAAU;AAAA,MACV,IAAI;AAAA,QACF,IAAI;AAAA,QACJ,IAAI;AAAA,QACJ,IAAI;AAAA,QACJ,iBAAiB,WACf,MAAM,QAAQ,SAAS,UACnB,MAAM,QAAQ,KAAK,GAAG,IACtB,MAAM,QAAQ,KAAK,GAAG;AAAA,MAC9B;AAAA,MAEA,0BAAAE,KAACD,aAAA,EAAW,SAAQ,SAAQ,OAAM,kBAAiB,OAAM,UACtD,4BAAe,WAAW,iDAC7B;AAAA;AAAA,EACF;AAEJ;;;ACxBA,SAAS,QAAAE,OAAM,SAAS,cAAAC,mBAAkB;AAmHpC,SAgBI,OAAAC,OAhBJ,QAAAC,aAAA;AAzBC,IAAM,YAAY,CAAC;AAAA,EACxB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAsB;AACpB,QAAM,kBAAkB;AAAA,IACtB,WAAW,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE;AAAA,IACjC,WAAW,EAAE,IAAI,IAAI,IAAI,GAAG,IAAI,EAAE;AAAA,EACpC;AACA,QAAM,uBAAuB,EAAE,IAAI,IAAI,IAAI,GAAG,IAAI,EAAE;AACpD,QAAM,OAAO,YAAY;AACzB,QAAM,YAAY,iBAAiB;AAEnC,SACE,gBAAAA;AAAA,IAACH;AAAA,IAAA;AAAA,MACC,MAAM;AAAA,MACN,IAAI;AAAA,QACF,SAAS;AAAA,QACT,eAAe,EAAE,IAAI,UAAU,IAAI,OAAO,IAAI,MAAM;AAAA,QACpD,WAAW,EAAE,SAAS,WAAW,UAAU,SAAS;AAAA,MACtD;AAAA,MAEA;AAAA,wBAAAG;AAAA,UAACH;AAAA,UAAA;AAAA,YACC,MAAM,KAAK;AAAA,YACX,IAAI;AAAA,cACF,SAAS;AAAA,cACT,UAAU;AAAA,cACV,WAAW,EAAE,IAAI,QAAQ,IAAI,SAAS,IAAI,QAAQ;AAAA,cAClD,GAAG;AAAA,YACL;AAAA,YAEC;AAAA;AAAA,cAAM;AAAA;AAAA;AAAA,QACT;AAAA,QACA,gBAAAE;AAAA,UAACF;AAAA,UAAA;AAAA,YACC,MAAM,KAAK;AAAA,YACX,IAAI,EAAE,SAAS,OAAO,SAAS,QAAQ,UAAU,OAAO;AAAA,YAExD,0BAAAE,MAAC,WAAQ,OAAO,OAAO,OAAK,MAC1B,0BAAAA;AAAA,cAACD;AAAA,cAAA;AAAA,gBACC,IAAI;AAAA,kBACF,UAAU;AAAA,kBACV,WAAW;AAAA,kBACX,UAAU;AAAA,kBACV,SAAS;AAAA,kBACT,cAAc;AAAA,kBACd,iBAAiB;AAAA,kBACjB,iBAAiB;AAAA,kBACjB,GAAG;AAAA,kBACH,OAAO;AAAA,gBACT;AAAA,gBAEC,kBAAQ,QAAQ;AAAA;AAAA,YACnB,GACF;AAAA;AAAA,QACF;AAAA;AAAA;AAAA,EACF;AAEJ;;;AC7IgB,qBAAAG,WAAA,OAAAC,aAAA;AAJT,IAAM,WAAW,CAAC;AAAA,EACvB;AAAA,EACA;AACF,MAAwC;AACtC,SAAO,OAAO,gBAAAA,MAAAD,WAAA,EAAG,UAAS,IAAM;AAClC;;;ACVA,SAAS,OAAAE,MAAK,WAAAC,UAAS,QAAAC,OAAM,OAAO,cAAAC,mBAAkB;AAEtD,SAAS,QAAAC,OAAM,WAAAC,gBAAe;AA6ExB,qBAAAC,WAUQ,OAAAC,OAFF,QAAAC,aARN;AA7DN,IAAM,kBAAkB,CAAC,UAAsC,cAAc;AAC3E,QAAM,SAAS;AAAA,IACb,SAAS;AAAA,MACP,SAAS;AAAA,MACT,OAAO;AAAA,IACT;AAAA,IACA,MAAM;AAAA,MACJ,SAAS;AAAA,MACT,OAAO;AAAA,IACT;AAAA,IACA,MAAM;AAAA,MACJ,SAAS;AAAA,MACT,OAAO;AAAA,IACT;AAAA,IACA,SAAS;AAAA,MACP,SAAS;AAAA,MACT,OAAO;AAAA,IACT;AAAA,IACA,OAAO;AAAA,MACL,SAAS;AAAA,MACT,OAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,OAAO,OAAO;AACvB;AAGO,IAAM,aAAaJ;AAAA,EACxB,CAAC;AAAA,IACC;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,EACF,MAAM;AACJ,UAAM,cAAcC,SAAQ,MAAM,gBAAgB,OAAO,GAAG,CAAC,OAAO,CAAC;AAErE,UAAM,WAAWA;AAAA,MACf,OAAO;AAAA,QACL,IAAI;AAAA,QACJ,IAAI;AAAA,QACJ,OAAO;AAAA,QACP,GAAG;AAAA,QACH,GAAG;AAAA,MACL;AAAA,MACA,CAAC,aAAa,OAAO;AAAA,IACvB;AAEA,UAAM,YAAYA;AAAA,MAChB,OAAO;AAAA,QACL,SAAS;AAAA,QACT,GAAG;AAAA,MACL;AAAA,MACA,CAAC,WAAW;AAAA,IACd;AAEA,WACE,gBAAAG,MAAAF,WAAA,EACE;AAAA,sBAAAE,MAACR,MAAA,EAAI,IAAI,EAAE,SAAS,QAAQ,eAAe,UAAU,OAAO,OAAO,GACjE;AAAA,wBAAAQ;AAAA,UAAC;AAAA;AAAA,YACC,WAAU;AAAA,YACV,gBAAe;AAAA,YACf,YAAW;AAAA,YACX,IAAI;AAAA,YAEJ;AAAA,8BAAAA,MAAC,SAAM,WAAU,OAAM,YAAW,UAAS,SAAS,GACjD;AAAA;AAAA,gBACD,gBAAAD,MAACJ,aAAA,EAAW,IAAI,EAAE,UAAU,QAAQ,YAAY,IAAI,GACjD,iBACH;AAAA,iBACF;AAAA,cACC;AAAA;AAAA;AAAA,QACH;AAAA,QACA,gBAAAI,MAACN,UAAA,EAAQ;AAAA,SACX;AAAA,MACA,gBAAAM,MAACL,OAAA,EAAK,WAAS,MAAC,SAAkB,IAAI,WACnC,UACH;AAAA,OACF;AAAA,EAEJ;AACF;;;ACxGA,SAAS,kBAAkB;AAE3B,SAAS,OAAAO,MAAK,KAAK,YAAY;AAE/B,SAAgB,gBAAgB;AAgC5B,SAQQ,OAAAC,OARR,QAAAC,aAAA;AAhBG,IAAM,aAAa,CAAC;AAAA,EACzB;AAAA,EACA,eAAe;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAA2C;AACzC,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAiB,YAAY;AAEvD,QAAM,eAAe,CAAC,OAA6B,aAAqB;AACtE,aAAS,QAAQ;AACjB,QAAI,YAAa,aAAY,QAAQ;AAAA,EACvC;AAEA,SACE,gBAAAA,MAAC,cAAW,OACV;AAAA,oBAAAD,MAACD,MAAA,EAAI,IAAI,EAAE,cAAc,GAAG,aAAa,WAAW,OAAO,OAAO,GAChE,0BAAAC;AAAA,MAAC;AAAA;AAAA,QACC;AAAA,QACA,UAAU;AAAA,QACV,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,GAAG,OAAO;AAAA,QAE7B,eAAK,IAAI,SACR,gBAAAA;AAAA,UAAC;AAAA;AAAA,YAEC,OAAO,IAAI;AAAA,YACX,OAAO,IAAI;AAAA,YACX,UAAU,IAAI,eAAe;AAAA,YAC7B,IAAI,EAAE,UAAU,QAAQ,GAAG,MAAM;AAAA;AAAA,UAJ5B,IAAI;AAAA,QAKX,CACD;AAAA;AAAA,IACH,GACF;AAAA,IAEC;AAAA,KACH;AAEJ;;;ACzDA,SAAS,iBAAAE,sBAAqB;AAY5B,gBAAAC,aAAA;AAJK,IAAM,eAA4C,CAAC;AAAA,EACxD,UAAU;AAAA,EACV,GAAG;AACL,MACE,gBAAAA;AAAA,EAACD;AAAA,EAAA;AAAA,IACC;AAAA,IACA,SAAQ;AAAA,IACR,OAAM;AAAA,IACN,MAAK;AAAA,IACJ,GAAG;AAAA,IACJ,IAAI,EAAE,YAAY,IAAI;AAAA,IACvB;AAAA;AAED;;;ACrBF,SAAS,kBAAkB;AAqBpB,SAAS,cACd,WAGA;AACA,SAAO;AAAA,IACL,CAAC,OAAO,QAAQ,UAAU,EAAE,GAAG,OAAO,IAAI,CAAC;AAAA,EAC7C;AACF;;;ACzBO,IAAM,SAAsB;AAAA,EACjC,iBAAiB;AAAA,EACjB,YAAY;AAAA;AAEd;AAEO,IAAM,mBAAmB;AAAA,EAC9B,UAAU;AAAA;AAAA,EACV,MAAM;AAAA;AAAA,EACN,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,MAAM;AAAA,EACN,MAAM;AAAA;AAAA,EACN,OAAO;AAAA,IACL,UAAU;AAAA;AAAA,IACV,MAAM;AAAA;AAAA,EACR;AAAA,EACA,WAAW;AAAA,IACT,UAAU;AAAA;AAAA,IACV,MAAM;AAAA;AAAA,IACN,aAAa;AAAA;AAAA,IACb,WAAW;AAAA,EACb;AACF;;;AC5BA,SAAS,WAAAE,gBAAe;AAKjB,SAAS,aAAa,SAA0B,CAAC,GAAG;AACzD,SAAOC;AAAA,IACL,MAAM,gBAAgB,MAAM;AAAA;AAAA,IAE5B;AAAA,MACE,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,MACP,OAAO;AAAA,IACT;AAAA,EACF;AACF;;;ACnBA,SAAS,eAAAC,oBAAmB;AAE5B,SAAS,aAAa;AAwCf,IAAM,sBAAsB,CAAmC;AAAA,EACpE;AAAA,EACA,iBAAiB;AAAA,IACf,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAAA,EACA,eAAe;AAAA,IACb,WAAW;AAAA,IACX,SAAS;AAAA,EACX;AACF,MAA2E;AACzE,QAAM,gBAAgBA;AAAA,IACpB,CACE,QACA,cACuB;AACvB,UAAI,CAAC,UAAU,CAAC,OAAO,SAAS,EAAG,QAAO;AAE1C,YAAM,aAAa,OAAO,SAAS;AAEnC,UAAI,OAAO,eAAe,UAAU;AAClC,eAAO;AAAA,MACT;AAEA,UAAI,MAAM,QAAQ,UAAU,GAAG;AAC7B,eAAO,WAAW,KAAK,IAAI;AAAA,MAC7B;AAEA,UAAI,OAAO,eAAe,YAAY,aAAa,YAAY;AAC7D,eAAO,WAAW;AAAA,MACpB;AAEA,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH;AAEA,QAAM,gBAAgBA;AAAA,IACpB,CAAC,WAAoB,iBAA0B;AAC7C,UAAI,iBAAiB,UAAa,eAAe,GAAG;AAClD,cAAM;AAAA,UACJ,YAAY,eAAe,SAAS,eAAe;AAAA,QACrD;AAEA,eAAO;AAAA,MACT,WAAW,iBAAiB,GAAG;AAC7B,cAAM,MAAM,aAAa,SAAS;AAElC,eAAO;AAAA,MACT;AAGA,YAAM,QAAQ,YAAY,eAAe,SAAS,eAAe,MAAM;AAEvE,aAAO;AAAA,IACT;AAAA,IACA,CAAC,gBAAgB,YAAY;AAAA,EAC/B;AAEA,QAAM,cAAcA;AAAA,IAClB,CAAC,mBAA6B;AAC5B,UACE,eAAe,SAAS,sBACxB,eAAe,UACf,UACA;AAEA,eAAO,KAAK,eAAe,MAAM,EAAE,QAAQ,eAAa;AACtD,gBAAM,aAAa,cAAc,eAAe,QAAQ,SAAS;AAEjE,cAAI,YAAY;AACd,qBAAS,WAAiC;AAAA,cACxC,MAAM;AAAA,cACN,SAAS;AAAA,YACX,CAAC;AAAA,UACH;AAAA,QACF,CAAC;AAGD,cAAM;AAAA,UACJ,eAAe,SAAS;AAAA,QAC1B;AAAA,MACF,OAAO;AAEL,cAAM,MAAM,eAAe,SAAS,aAAa,OAAO;AAAA,MAC1D;AAAA,IACF;AAAA,IACA,CAAC,aAAa,SAAS,eAAe,QAAQ;AAAA,EAChD;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;AAMO,IAAM,mBAAmB,CAAC;AAAA,EAC/B,iBAAiB;AAAA,EACjB,eAAe;AACjB,IAA6B,CAAC,MAAiC;AAC7D,SAAO,oBAAoB;AAAA,IACzB,gBAAgB;AAAA,MACd,QAAQ;AAAA;AAAA,MACR,QAAQ;AAAA,IACV;AAAA,IACA,cAAc;AAAA,MACZ,WAAW;AAAA;AAAA,MACX,SAAS;AAAA,IACX;AAAA;AAAA,EAEF,CAAC;AACH;;;AC7JA,SAAS,sBAAsB;AAC/B,SAAS,WAAAC,gBAAe;AAGjB,IAAM,eAAN,MAAmB;AAAA,EACxB,YAAoB,aAA0B;AAA1B;AAAA,EAA2B;AAAA;AAAA;AAAA;AAAA,EAK/C,cAAiB,UAAmC;AAClD,WAAO,KAAK,YAAY,aAAgB,QAAQ;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKA,wBACE,UACA,QACe;AACf,UAAM,aAAa,KAAK,YAAY,aAAgB,QAAQ;AAE5D,QAAI,eAAe,QAAW;AAC5B,aAAO;AAAA,IACT;AAEA,WAAO,OAAO,UAAU;AAAA,EAC1B;AACF;AAEO,SAAS,kBAAgC;AAC9C,QAAM,cAAc,eAAe;AAEnC,SAAOA,SAAQ,MAAM,IAAI,aAAa,WAAW,GAAG,CAAC,WAAW,CAAC;AACnE;;;AC7BA,SAAS,gBAAgB;AAelB,IAAM,eAAe,CAC1B,YAC0C,SAAS,EAAE,QAAQ,CAAC;AAKzD,IAAM,gBAAgB,CAI3B,SACA,SACmC,SAAS,EAAE,SAAS,KAAK,CAAC;AAKxD,IAAM,iBAAiB,CAI5B,SACA,UAEA,SAAS,EAAE,SAAS,MAAM,MAAM,CAAC;;;AC/CnC,SAAS,WAAW,WAAAC,UAAS,YAAAC,iBAAgB;AAE7C,SAAS,YAAAC,iBAAgB;AAUlB,IAAM,oBAAoB,CAK/B,SACA,MACA,cACY;AACZ,QAAM,QAAQA,UAAS,EAAE,SAAS,KAAK,CAAC;AAExC,SAAOF,SAAQ,MAAM,UAAU,KAAK,GAAG,CAAC,OAAO,SAAS,CAAC;AAC3D;AAKO,IAAM,kBAAkB,CAI7B,SACA,MACA,iBACmC;AACnC,QAAM,QAAQE,UAAS,EAAE,SAAS,KAAK,CAAC;AAExC,SAAO,SAAS;AAClB;AAKO,IAAM,kBAAkB,CAI7B,SACA,MACA,eAAe,UACH;AACZ,QAAM,QAAQA,UAAS,EAAE,SAAS,KAAK,CAAC;AAExC,SAAO,QAAQ,SAAS,YAAY;AACtC;AAKO,IAAM,gBAAgB,CAI3B,SACA,WAC2D;AAC3D,QAAM,SAASA,UAAS,EAAE,SAAS,MAAM,OAAO,CAAC;AAEjD,SAAOF,SAAQ,MAAM;AACnB,UAAM,SAAS,CAAC;AAEhB,WAAO,QAAQ,CAAC,OAAO,UAAU;AAC/B,aAAO,KAAwB,IAAI,OAAO,KAAK;AAAA,IACjD,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,QAAQ,MAAM,CAAC;AACrB;AAKO,IAAM,sBAAsB,CAIjC,SACA,MACA,aACA,aAC+C;AAC/C,QAAM,cAAcE,UAAS;AAAA,IAC3B;AAAA,IACA;AAAA,IACA,UAAU,CAAC;AAAA,EACb,CAAC;AAED,SAAO,cAAc,cAAc;AACrC;AAKO,IAAM,oBAAoB,CAI/B,SACA,MACA,QAAQ,QAC2B;AACnC,QAAM,QAAQA,UAAS,EAAE,SAAS,KAAK,CAAC;AACxC,QAAM,CAAC,gBAAgB,iBAAiB,IACtCD,UAAyC,KAAK;AAEhD,YAAU,MAAM;AACd,UAAM,QAAQ,WAAW,MAAM;AAC7B,wBAAkB,KAAK;AAAA,IACzB,GAAG,KAAK;AAER,WAAO,MAAM,aAAa,KAAK;AAAA,EACjC,GAAG,CAAC,OAAO,KAAK,CAAC;AAEjB,SAAO;AACT;AAKO,IAAM,mBAAmB,CAK9B,SACA,MACA,UACA,OAA6B,CAAC,MAClB;AACZ,QAAM,QAAQC,UAAS,EAAE,SAAS,KAAK,CAAC;AAExC,SAAOF;AAAA,IACL,MAAM,SAAS,KAAK;AAAA,IACpB,CAAC,OAAO,UAAU,GAAG,IAAI;AAAA;AAAA,EAC3B;AACF;;;AC/FO,IAAM,aAAa;AAAA;AAAA;AAAA,EAGxB,MAAM;AAAA;AAAA,EAEN,OAAO;AAAA;AAAA,EAEP,QAAQ;AAAA;AAAA;AAAA,EAIR,WAAW;AAAA;AAAA,EAEX,aAAa;AAAA;AAAA,EAEb,SAAS;AAAA;AAAA,EAET,OAAO;AAAA;AAAA,EAEP,aAAa;AAAA;AAAA,EAEb,WAAW;AAAA;AAAA,EAEX,UAAU;AACZ;;;AC5EO,IAAM,uBAAuB,CAAC,UACnC,OAAO,OAAO,KAAK,EAAE;AAAA,EACnB,OAAK,MAAM,QAAQ,MAAM,UAAa,OAAO,CAAC,EAAE,KAAK,MAAM;AAC7D,EAAE;;;ACFJ,OAAO,WAAW;AAClB,OAAO,cAAc;AACrB,OAAO,kBAAkB;AA0BzB,MAAM,OAAO,QAAQ;AACrB,MAAM,OAAO,YAAY;AAYlB,IAAM,iBAAiB;AAAA,EAC5B,UAAU;AAAA;AAAA,EACV,MAAM;AAAA;AAAA,EACN,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,MAAM;AAAA,EACN,MAAM;AAAA;AAAA,EACN,OAAO;AAAA,IACL,UAAU;AAAA;AAAA,IACV,MAAM;AAAA;AAAA,EACR;AAAA,EACA,WAAW;AAAA,IACT,UAAU;AAAA;AAAA,IACV,MAAM;AAAA;AAAA,IACN,aAAa;AAAA;AAAA,IACb,WAAW;AAAA,EACb;AACF;AAEA,IAAM,cAAc,CAAC,SACnB,SAAS,QAAQ,SAAS,UAAa,MAAM,IAAI,EAAE,QAAQ;AAItD,SAAS,MAAM,UAA2B;AAC/C,SAAO,MAAM,oBAAI,KAAK,CAAC,EAAE,QAAQ,KAAK,EAAE,OAAO,QAAQ;AACzD;AAOO,SAAS,UAAU,MAAwB,UAA2B;AAC3E,MAAI,CAAC,YAAY,IAAI,GAAG;AACtB,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,IAAI,EAAE,OAAO,YAAY,eAAe,QAAQ;AAC/D;AAOO,SAAS,MAAM,MAAwB,UAA2B;AACvE,MAAI,CAAC,YAAY,IAAI,GAAG;AACtB,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,IAAI,EAAE,OAAO,YAAY,eAAe,IAAI;AAC3D;AAOO,SAAS,MAAM,MAAwB,UAA2B;AACvE,MAAI,CAAC,YAAY,IAAI,GAAG;AACtB,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,IAAI,EAAE,OAAO,YAAY,eAAe,IAAI;AAC3D;AAOO,SAAS,WAAW,MAAiD;AAC1E,MAAI,CAAC,YAAY,IAAI,GAAG;AACtB,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,IAAI,EAAE,QAAQ;AAC7B;AAOO,SAAS,OAAO,MAAgC;AACrD,MAAI,CAAC,YAAY,IAAI,GAAG;AACtB,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,IAAI,EAAE,MAAM,IAAI;AAC/B;AAOO,SAAS,WACd,WACA,WACA,SACS;AACT,MACE,CAAC,YAAY,SAAS,KACtB,CAAC,YAAY,SAAS,KACtB,CAAC,YAAY,OAAO,GACpB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,qBAAqB,WAAW,SAAS;AAC/C,QAAM,qBAAqB,WAAW,SAAS;AAC/C,QAAM,mBAAmB,WAAW,OAAO;AAE3C,MACE,uBAAuB,kBACvB,uBAAuB,kBACvB,qBAAqB,gBACrB;AACA,WAAO;AAAA,EACT;AAEA,SACE,sBAAsB,sBACtB,sBAAsB;AAE1B;AAOO,SAAS,SACd,WACA,SACS;AACT,MAAI,CAAC,YAAY,SAAS,KAAK,CAAC,YAAY,OAAO,GAAG;AACpD,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,SAAS,EAAE,QAAQ,OAAO;AACzC;AAOO,SAAS,QACd,WACA,SACA,eACS;AACT,MAAI,CAAC,YAAY,SAAS,KAAK,CAAC,YAAY,OAAO,GAAG;AACpD,WAAO;AAAA,EACT;AAEA,SAAO,MAAM,SAAS,EAAE,OAAO,SAAS,iBAAiB,MAAM;AACjE;AASO,SAAS,qBACd,WACA,SACA,SACQ;AACR,MACE,CAAC,YAAY,SAAS,KACtB,CAAC,YAAY,OAAO,KACpB,SAAS,WAAW,OAAO,GAC3B;AACA,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,GAAG,MAAM,SAAS,CAAC,MAAM,MAAM,OAAO,CAAC;AAEnD,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,QAAQ,WAAW,SAAS,MAAM;AACrD,QAAM,cAAc,QAAQ,WAAW,SAAS,OAAO;AACvD,QAAM,YAAY,QAAQ,WAAW,SAAS,KAAK;AAEnD,MAAI,cAAc,CAAC,aAAa;AAC9B,YAAQ,GAAG,MAAM,WAAW,QAAQ,CAAC,MAAM,MAAM,OAAO,CAAC;AAAA,EAC3D,WAAW,cAAc,eAAe,CAAC,WAAW;AAClD,YAAQ,GAAG,MAAM,WAAW,IAAI,CAAC,MAAM,MAAM,OAAO,CAAC;AAAA,EACvD,WAAW,cAAc,eAAe,WAAW;AACjD,YAAQ,GAAG,MAAM,OAAO,CAAC;AAAA,EAC3B;AAEA,SAAO;AACT;AAiBO,SAAS,KAAK;AAAA,EACnB,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,UAAU;AAAA,EACV,eAAe;AACjB,GAAkB;AAChB,QAAM,SAAS,MAAM,EAClB;AAAA,IACC,MAAM,SAAS;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EACC,OAAO;AAEV,SAAO;AACT;AAKO,SAAS,KAAK;AAAA,EACnB,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,UAAU;AAAA,EACV,eAAe;AACjB,GAAkB;AAChB,QAAM,SAAS,MAAM,EAClB;AAAA,IACC,MAAM,SAAS;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EACC,OAAO;AAEV,SAAO;AACT;;;ACzSO,SAAS,eACd,MACA,gBAA4B,CAAC,GACA;AAC7B,QAAM,MAAM,CAAC;AAEb,aAAW,OAAO,OAAO,KAAK,IAAI,GAAqB;AACrD,UAAM,QAAQ,KAAK,GAAG;AACtB,UAAM,OAAO,OAAO;AAEpB,QAAI,SAAS,UAAU;AACrB,UAAI,GAAa,IAAI;AAAA,IACvB,WAAW,SAAS,YAAY,SAAS,WAAW;AAClD,UAAI,GAAa,IAAI;AAAA,IACvB,WAAW,iBAAiB,MAAM;AAChC,UAAI,GAAa,IAAI;AAAA,IACvB,OAAO;AACL,UAAI,GAAa,IAAI;AAAA,IACvB;AAAA,EACF;AAEA,SAAO,EAAE,GAAG,KAAK,GAAG,cAAc;AACpC;;;ACtCA,SAAS,QAAQ,WAAAG,gBAAe;AASzB,SAAS,kBAAkB,cAA0C;AAC1E,QAAM,cAAc,OAAO,gBAAgB,CAAC;AAE5C,QAAM,iBAAiBA,SAAQ,MAAM;AACnC,QAAI,iBAAiB,QAAW;AAC9B,kBAAY,UAAU;AAAA,IACxB;AAEA,WAAO,YAAY;AAAA,EACrB,GAAG,CAAC,YAAY,CAAC;AAEjB,SAAO;AACT;",
  "names": ["config", "jsx", "Button", "jsx", "jsx", "jsx", "jsx", "memo", "jsx", "memo", "Box", "Card", "CardContent", "Typography", "Fragment", "jsx", "jsxs", "Box", "Typography", "jsx", "Grid", "Typography", "jsx", "jsxs", "Fragment", "jsx", "Box", "Divider", "Grid", "Typography", "memo", "useMemo", "Fragment", "jsx", "jsxs", "Box", "jsx", "jsxs", "LoadingButton", "jsx", "useMemo", "useMemo", "useCallback", "useMemo", "useMemo", "useState", "useWatch", "useMemo"]
}
