@gnwebsoft/ui 4.0.1 → 4.0.2

package/dist/chunk-QLQ6OH25.cjs

@@ -0,0 +1,2490 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// 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) {
+    const err = error;
+    if (err.type || err.title || err.errors) {
+      return Object.assign(
+        err instanceof Error ? err : 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 (_optionalChain([err, 'access', _ => _.message, 'optionalAccess', _2 => _2.includes, 'call', _3 => _3("timeout")])) {
+      return Object.assign(new Error(err.message), {
+        type: "timeout_error",
+        title: "Request Timeout",
+        status: 408,
+        traceId: correlationId,
+        isAborted: true,
+        config
+      });
+    }
+    if (_optionalChain([err, 'access', _4 => _4.message, 'optionalAccess', _5 => _5.includes, 'call', _6 => _6("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 = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
+  /**
+   * Array of registered request interceptors
+   * @private
+   */
+  __init() {this.requestInterceptors = []}
+  /**
+   * Array of registered response interceptors
+   * @private
+   */
+  __init2() {this.responseInterceptors = []}
+  /**
+   * Array of registered error interceptors
+   * @private
+   */
+  __init3() {this.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.data?.result) {
+   *     response.data = response.data.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;
+  }
+}, _class);
+
+// src/core/api/RequestManager.ts
+var RequestManager = (_class2 = class {constructor() { _class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this); }
+  /**
+   * Map of active request keys to their abort controllers
+   * @private
+   */
+  __init4() {this.activeRequests = /* @__PURE__ */ new Map()}
+  /**
+   * Map of request keys to their correlation IDs for tracing
+   * @private
+   */
+  __init5() {this.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);
+  }
+}, _class2);
+
+// 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 (_optionalChain([signal, 'optionalAccess', _7 => _7.aborted])) {
+        throw new Error(signal.reason || "Request aborted");
+      }
+      return await fn();
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" || _optionalChain([signal, 'optionalAccess', _8 => _8.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 (_optionalChain([contentType, 'optionalAccess', _9 => _9.includes, 'call', _10 => _10("application/json")])) {
+      return response.json();
+    } else if (_optionalChain([contentType, 'optionalAccess', _11 => _11.includes, 'call', _12 => _12("text/")])) {
+      return response.text();
+    } else if (_optionalChain([contentType, 'optionalAccess', _13 => _13.includes, 'call', _14 => _14("application/octet-stream")])) {
+      return response.blob();
+    } else {
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch (e2) {
+        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 = (_class3 = class {
+  
+  
+  __init6() {this.interceptorManager = new InterceptorManager()}
+  __init7() {this.signalManager = new SignalManager()}
+  __init8() {this.errorNormalizer = new ErrorNormalizer()}
+  __init9() {this.responseParser = new ResponseParser()}
+  __init10() {this.urlBuilder = new UrlBuilder()}
+  __init11() {this.retryHandler = new RetryHandler()}
+  __init12() {this.requestManager = new RequestManager()}
+  __init13() {this.authToken = null}
+  __init14() {this.refreshTokenPromise = null}
+  __init15() {this.correlationIdPrefix = "api"}
+  __init16() {this.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) {;_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);
+    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.data) {
+   *     response.data = camelCaseKeys(response.data);
+   *   }
+   *   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,
+        _optionalChain([config, 'access', _15 => _15.cancelToken, 'optionalAccess', _16 => _16.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}`);
+      }
+      if (finalConfig.body && typeof finalConfig.body === "object" && !(finalConfig.body instanceof FormData)) {
+        headers.set("Content-Type", "application/json");
+        finalConfig.body = JSON.stringify(finalConfig.body);
+      }
+      finalConfig.headers = headers;
+      const fetchPromise = async () => {
+        try {
+          const response = await fetch(url, {
+            ...finalConfig,
+            signal: combinedController.signal
+          });
+          const responseData = await this.responseParser.parseResponse(response);
+          if (!response.ok) {
+            const error = Object.assign(
+              new Error(
+                responseData.title || `HTTP ${response.status}: ${response.statusText}`
+              ),
+              {
+                type: responseData.type || this.errorNormalizer.getErrorType(response.status),
+                title: responseData.title || this.errorNormalizer.getErrorTitle(response.status),
+                status: response.status,
+                traceId: responseData.traceId || correlationId,
+                errors: responseData.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 { data, 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 { data, 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 { data, 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 { data, 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 { data, error } = await client.filter<User, UserFilter>(
+   *   '/users/filter',
+   *   {
+   *     pageOffset: 0,
+   *     pageSize: 20,
+   *     sortField: 'createdAt',
+   *     sortOrder: 'desc',
+   *     filterModel: { status: 'active' }
+   *   }
+   * );
+   *
+   * if (data) {
+   *   console.log(`Found ${data.Total} users`);
+   *   console.log('Users:', data.Data);
+   * }
+   * ```
+   */
+  filter(url, data, config) {
+    const mergedData = { ...data, ...data.filterModel };
+    return this.request(url, {
+      ...config,
+      method: "POST",
+      body: mergedData
+    });
+  }
+}, _class3);
+
+// src/core/api/createApiClient.ts
+var globalApiClient = null;
+function createApiClient(config = {}) {
+  const {
+    baseURL = import.meta.env.VITE_API_URL,
+    timeout = 3e4,
+    correlationIdPrefix = "api",
+    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 {
+  
+  
+  
+  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);
+    _optionalChain([this, 'access', _17 => _17.cancelResolve, 'optionalCall', _18 => _18()]);
+  }
+  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
+var _react = require('react');
+function useValidationErrors(error) {
+  const getFieldError = _react.useCallback.call(void 0, 
+    (field) => {
+      if (!_optionalChain([error, 'optionalAccess', _19 => _19.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 = _react.useCallback.call(void 0, 
+    (field) => {
+      return !!getFieldError(field);
+    },
+    [getFieldError]
+  );
+  const getAllErrors = _react.useCallback.call(void 0, () => {
+    if (!_optionalChain([error, 'optionalAccess', _20 => _20.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: _optionalChain([error, 'optionalAccess', _21 => _21.errors])
+  };
+}
+
+// src/core/components/AuthorizedView/AuthorizedView.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var AuthorizedView = ({ children, show }) => {
+  if (!show) return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, {});
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children });
+};
+
+// src/core/components/CancelButton/CancelButton.tsx
+var _material = require('@mui/material');
+
+var CancelButton = ({
+  children = "Cancel",
+  variant = "outlined",
+  sx,
+  ...rest
+}) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Button, { variant, sx: { width: "6rem", ...sx }, ...rest, children });
+
+// src/core/components/ClearButton/ClearButton.tsx
+
+
+var ClearButton = ({
+  isSubmitting,
+  handleClear,
+  sx,
+  storeKey
+}) => {
+  const onClick = () => {
+    handleClear();
+    if (storeKey != null) {
+      localStorage.removeItem(storeKey);
+    }
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Button,
+    {
+      variant: "outlined",
+      onClick,
+      disabled: isSubmitting,
+      sx,
+      children: "Clear"
+    }
+  );
+};
+
+// src/core/components/Containers/SimpleContainer.tsx
+
+
+var SimpleContainer = ({
+  children,
+  className,
+  sx
+}) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Container, { className, sx: { ...sx }, children });
+
+// src/core/components/FilterButton/FilterButton.tsx
+var _FilterAlt = require('@mui/icons-material/FilterAlt'); var _FilterAlt2 = _interopRequireDefault(_FilterAlt);
+var _lab = require('@mui/lab');
+
+
+var FilterButton = ({
+  isSubmitting,
+  show,
+  title,
+  icon,
+  sx,
+  iconSx
+}) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _lab.LoadingButton,
+    {
+      type: "submit",
+      variant: "contained",
+      loading: isSubmitting,
+      disabled: !show,
+      disableRipple: true,
+      color: "primary",
+      sx: {
+        display: "flex",
+        alignItems: "center",
+        ...sx
+      },
+      startIcon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Badge, { color: "error", variant: "standard", children: icon ? icon : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _FilterAlt2.default, { width: "20", height: "20", sx: iconSx }) }),
+      children: _optionalChain([title, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()]) === "" || !title ? "Filter" : title
+    }
+  );
+};
+
+// src/core/components/FilterDisplay/FilterChip.tsx
+var _Chip = require('@mui/material/Chip'); var _Chip2 = _interopRequireDefault(_Chip);
+
+
+var FilterChip = _react.memo.call(void 0, 
+  ({
+    fieldKey,
+    filter,
+    onDelete
+  }) => {
+    const hasValue = filter.Value !== null && filter.Value !== void 0 && filter.Value !== "";
+    const label = `${fieldKey.replace("PK", "")}: ${filter.Label}`;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _Chip2.default,
+      {
+        label,
+        variant: hasValue ? "filled" : "outlined",
+        size: "small",
+        onDelete: hasValue ? onDelete : void 0
+      },
+      fieldKey
+    );
+  }
+);
+FilterChip.displayName = "FilterChip";
+
+// src/core/components/FilterDisplay/FilterDisplay.tsx
+
+
+
+var ProgramsFilterDisplay = _react.memo.call(void 0, 
+  (props) => {
+    const { friendlyFilter, onFriendlyFilterChange } = props;
+    const deleteHandlers = _react.useMemo.call(void 0, () => {
+      if (!onFriendlyFilterChange) return {};
+      const handlers = {};
+      for (const key of Object.keys(friendlyFilter)) {
+        handlers[key] = () => onFriendlyFilterChange(key);
+      }
+      return handlers;
+    }, [onFriendlyFilterChange, friendlyFilter]);
+    const chipList = _react.useMemo.call(void 0, () => {
+      return Object.entries(friendlyFilter).map(([key, filter]) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        FilterChip,
+        {
+          fieldKey: key,
+          filter,
+          onDelete: deleteHandlers[key]
+        },
+        key
+      ));
+    }, [friendlyFilter, deleteHandlers]);
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Card, { sx: { mb: 2 }, children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.CardContent, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { variant: "h6", gutterBottom: true, children: "Active Filters" }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { display: "flex", gap: 1, flexWrap: "wrap", children: chipList })
+    ] }) });
+  }
+);
+ProgramsFilterDisplay.displayName = "FilterDisplay";
+
+// src/core/components/FilterWrapper/FilterWrapper.tsx
+var _ManageSearch = require('@mui/icons-material/ManageSearch'); var _ManageSearch2 = _interopRequireDefault(_ManageSearch);
+
+
+
+
+
+
+
+
+
+
+
+var FilterWrapper = ({
+  children,
+  title,
+  filterCount,
+  cardSx,
+  textSx,
+  icon,
+  iconSx,
+  showCount
+}) => {
+  const theme = _material.useTheme.call(void 0, );
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _material.Card,
+    {
+      sx: {
+        position: "relative",
+        borderRadius: "0px",
+        mb: 2,
+        ...cardSx
+      },
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.CardHeader,
+          {
+            sx: {
+              display: "flex",
+              flexWrap: "wrap",
+              p: "1rem",
+              ".MuiCardHeader-action": {
+                margin: 0,
+                alignSelf: "center"
+              },
+              alignItems: "center"
+            },
+            title: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Box, { sx: { display: "flex", alignItems: "center", gap: 0.5 }, children: [
+              icon ? icon : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _ManageSearch2.default,
+                {
+                  sx: {
+                    height: "2.5rem",
+                    color: theme.palette.primary.main,
+                    ...iconSx
+                  }
+                }
+              ),
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+                _material.Typography,
+                {
+                  variant: "h5",
+                  sx: {
+                    fontWeight: "bold",
+                    color: theme.palette.primary.main,
+                    ...textSx
+                  },
+                  children: [
+                    title ? title : "Filter",
+                    " ",
+                    showCount ? `(${filterCount ? filterCount : 0})` : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, {})
+                  ]
+                }
+              )
+            ] })
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Divider, {}),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.CardContent, { sx: { py: 2 }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { container: true, spacing: 2, children }) })
+      ]
+    }
+  );
+};
+
+// src/core/components/Footer/Footer.tsx
+
+
+var Footer = () => {
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Box,
+    {
+      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__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { variant: "body2", color: "text.secondary", align: "center", children: `\xA9 Copyright ${currentYear} GN. All rights reserved by Parul University.` })
+    }
+  );
+};
+
+// src/core/components/LabelText/LabelText.tsx
+
+
+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__ */ _jsxruntime.jsxs.call(void 0, 
+    _material.Grid,
+    {
+      size: container,
+      sx: {
+        display: "flex",
+        flexDirection: { xs: "column", sm: "row", md: "row" },
+        "&:hover": { bgcolor: "#efefef", overflow: "hidden" }
+      },
+      children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          _material.Grid,
+          {
+            size: size.labelSize,
+            sx: {
+              padding: "5px",
+              fontSize: "14px",
+              textAlign: { xs: "left", sm: "right", md: "right" },
+              ...labelSx
+            },
+            children: [
+              label,
+              " :"
+            ]
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.Grid,
+          {
+            size: size.valueSize,
+            sx: { padding: "5px", display: "flex", flexWrap: "wrap" },
+            children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Tooltip, { title: value, arrow: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              _material.Typography,
+              {
+                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
+
+var RenderIf = ({
+  show,
+  children
+}) => {
+  return show ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children }) : null;
+};
+
+// src/core/components/SectionBox/SectionBox.tsx
+
+
+
+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 = _react.memo.call(void 0, 
+  ({
+    title,
+    children,
+    spacing = 0,
+    containerSx,
+    titleSx,
+    variant = "default",
+    icon,
+    actions
+  }) => {
+    const themeColors = _react.useMemo.call(void 0, () => getSectionTheme(variant), [variant]);
+    const headerSx = _react.useMemo.call(void 0, 
+      () => ({
+        px: 1.5,
+        py: 0.1,
+        width: "fit-content",
+        ...themeColors,
+        ...titleSx
+      }),
+      [themeColors, titleSx]
+    );
+    const contentSx = _react.useMemo.call(void 0, 
+      () => ({
+        padding: "16px",
+        ...containerSx
+      }),
+      [containerSx]
+    );
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Box, { sx: { display: "flex", flexDirection: "column", width: "100%" }, children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          _material.Stack,
+          {
+            direction: "row",
+            justifyContent: "space-between",
+            alignItems: "center",
+            sx: headerSx,
+            children: [
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.Stack, { direction: "row", alignItems: "center", spacing: 1, children: [
+                icon,
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Typography, { sx: { fontSize: "15px", fontWeight: 400 }, children: title })
+              ] }),
+              actions
+            ]
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Divider, {})
+      ] }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { container: true, spacing, sx: contentSx, children })
+    ] });
+  }
+);
+
+// src/core/components/SimpleTabs/SimpleTabs.tsx
+
+
+
+
+var SimpleTabs = ({
+  tabs,
+  defaultValue = 1,
+  onTabChange,
+  children,
+  tabSx,
+  tabsSx
+}) => {
+  const [value, setValue] = _react.useState.call(void 0, defaultValue);
+  const handleChange = (event, newValue) => {
+    setValue(newValue);
+    if (onTabChange) onTabChange(newValue);
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _lab.TabContext, { value, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Box, { sx: { borderBottom: 1, borderColor: "divider", width: "100%" }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Tabs,
+      {
+        value,
+        onChange: handleChange,
+        sx: { px: 2, py: 0, ...tabsSx },
+        children: tabs.map((tab) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.Tab,
+          {
+            label: tab.label,
+            value: tab.value,
+            disabled: tab.permission === false,
+            sx: { fontSize: "1rem", ...tabSx }
+          },
+          tab.value
+        ))
+      }
+    ) }),
+    children
+  ] });
+};
+
+// src/core/components/SubmitButton/SubmitButton.tsx
+
+
+var SubmitButton = ({
+  loading = false,
+  ...rest
+}) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  _lab.LoadingButton,
+  {
+    loading,
+    variant: "contained",
+    color: "primary",
+    type: "submit",
+    ...rest,
+    sx: { fontWeight: 400 },
+    children: "Submit"
+  }
+);
+
+// src/core/components/WithRef/WithRef.tsx
+
+function withDataModal(component) {
+  return _react.forwardRef.call(void 0, 
+    (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
+
+function useApiClient(config = {}) {
+  return _react.useMemo.call(void 0, 
+    () => 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
+
+var _sonner = require('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 = _react.useCallback.call(void 0, 
+    (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 = _react.useCallback.call(void 0, 
+    (isEditing, rowsAffected) => {
+      if (rowsAffected !== void 0 && rowsAffected > 0) {
+        _sonner.toast.success(
+          isEditing ? successMessage.update : successMessage.create
+        );
+        return true;
+      } else if (rowsAffected === 0) {
+        _sonner.toast.error(errorMessage.noChanges);
+        return false;
+      }
+      _sonner.toast.success(isEditing ? successMessage.update : successMessage.create);
+      return true;
+    },
+    [successMessage, errorMessage]
+  );
+  const handleError = _react.useCallback.call(void 0, 
+    (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
+            });
+          }
+        });
+        _sonner.toast.error(
+          processedError.title || "Please check the form for validation errors"
+        );
+      } else {
+        _sonner.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
+var _reactquery = require('@tanstack/react-query');
+
+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 = _reactquery.useQueryClient.call(void 0, );
+  return _react.useMemo.call(void 0, () => new CacheUtility(queryClient), [queryClient]);
+}
+
+// src/core/utils/watch/core.ts
+var _reacthookform = require('react-hook-form');
+var useWatchForm = (control) => _reacthookform.useWatch.call(void 0, { control });
+var useWatchField = (control, name) => _reacthookform.useWatch.call(void 0, { control, name });
+var useWatchFields = (control, names) => _reacthookform.useWatch.call(void 0, { control, name: names });
+
+// src/core/utils/watch/utilities.ts
+
+
+var useWatchTransform = (control, name, transform) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return _react.useMemo.call(void 0, () => transform(value), [value, transform]);
+};
+var useWatchDefault = (control, name, defaultValue) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return _nullishCoalesce(value, () => ( defaultValue));
+};
+var useWatchBoolean = (control, name, defaultValue = false) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return Boolean(_nullishCoalesce(value, () => ( defaultValue)));
+};
+var useWatchBatch = (control, fields) => {
+  const values = _reacthookform.useWatch.call(void 0, { control, name: fields });
+  return _react.useMemo.call(void 0, () => {
+    const result = {};
+    fields.forEach((field, index) => {
+      result[field] = values[index];
+    });
+    return result;
+  }, [values, fields]);
+};
+var useWatchConditional = (control, name, shouldWatch, fallback) => {
+  const activeValue = _reacthookform.useWatch.call(void 0, {
+    control,
+    name,
+    disabled: !shouldWatch
+  });
+  return shouldWatch ? activeValue : fallback;
+};
+var useWatchDebounced = (control, name, delay = 300) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  const [debouncedValue, setDebouncedValue] = _react.useState.call(void 0, value);
+  _react.useEffect.call(void 0, () => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+};
+var useWatchSelector = (control, name, selector, deps = []) => {
+  const value = _reacthookform.useWatch.call(void 0, { control, name });
+  return _react.useMemo.call(void 0, 
+    () => 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
+var _dayjs = require('dayjs'); var _dayjs2 = _interopRequireDefault(_dayjs);
+var _duration = require('dayjs/plugin/duration'); var _duration2 = _interopRequireDefault(_duration);
+var _relativeTime = require('dayjs/plugin/relativeTime'); var _relativeTime2 = _interopRequireDefault(_relativeTime);
+_dayjs2.default.extend(_duration2.default);
+_dayjs2.default.extend(_relativeTime2.default);
+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 && _dayjs2.default.call(void 0, date).isValid();
+function today(template) {
+  return _dayjs2.default.call(void 0, /* @__PURE__ */ new Date()).startOf("day").format(template);
+}
+function fDateTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).format(_nullishCoalesce(template, () => ( formatPatterns.dateTime)));
+}
+function fDate(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).format(_nullishCoalesce(template, () => ( formatPatterns.date)));
+}
+function fTime(date, template) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).format(_nullishCoalesce(template, () => ( formatPatterns.time)));
+}
+function fTimestamp(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, date).valueOf();
+}
+function fToNow(date) {
+  if (!isValidDate(date)) {
+    return "Invalid date";
+  }
+  return _dayjs2.default.call(void 0, 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 _dayjs2.default.call(void 0, startDate).isAfter(endDate);
+}
+function fIsSame(startDate, endDate, unitToCompare) {
+  if (!isValidDate(startDate) || !isValidDate(endDate)) {
+    return false;
+  }
+  return _dayjs2.default.call(void 0, startDate).isSame(endDate, _nullishCoalesce(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 = _dayjs2.default.call(void 0, ).add(
+    _dayjs2.default.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 = _dayjs2.default.call(void 0, ).subtract(
+    _dayjs2.default.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
+
+function useStableRowCount(currentTotal) {
+  const rowCountRef = _react.useRef.call(void 0, currentTotal || 0);
+  const stableRowCount = _react.useMemo.call(void 0, () => {
+    if (currentTotal !== void 0) {
+      rowCountRef.current = currentTotal;
+    }
+    return rowCountRef.current;
+  }, [currentTotal]);
+  return stableRowCount;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.generateCorrelationId = generateCorrelationId; exports.RequestManager = RequestManager; exports.ApiClient = ApiClient; exports.createApiClient = createApiClient; exports.getGlobalApiClient = getGlobalApiClient; exports.setGlobalApiClient = setGlobalApiClient; exports.resetGlobalApiClient = resetGlobalApiClient; exports.CancelToken = CancelToken; exports.useValidationErrors = useValidationErrors; exports.AuthorizedView = AuthorizedView; exports.CancelButton = CancelButton; exports.ClearButton = ClearButton; exports.SimpleContainer = SimpleContainer; exports.FilterButton = FilterButton; exports.FilterChip = FilterChip; exports.ProgramsFilterDisplay = ProgramsFilterDisplay; exports.FilterWrapper = FilterWrapper; exports.Footer = Footer; exports.LabelText = LabelText; exports.RenderIf = RenderIf; exports.SectionBox = SectionBox; exports.SimpleTabs = SimpleTabs; exports.SubmitButton = SubmitButton; exports.withDataModal = withDataModal; exports.Config = Config; exports.dateTimePatterns = dateTimePatterns; exports.useApiClient = useApiClient; exports.useFormErrorHandler = useFormErrorHandler; exports.useDeleteHandler = useDeleteHandler; exports.CacheUtility = CacheUtility; exports.useCacheUtility = useCacheUtility; exports.useWatchForm = useWatchForm; exports.useWatchField = useWatchField; exports.useWatchFields = useWatchFields; exports.useWatchTransform = useWatchTransform; exports.useWatchDefault = useWatchDefault; exports.useWatchBoolean = useWatchBoolean; exports.useWatchBatch = useWatchBatch; exports.useWatchConditional = useWatchConditional; exports.useWatchDebounced = useWatchDebounced; exports.useWatchSelector = useWatchSelector; exports.typedWatch = typedWatch; exports.calculateFilterCount = calculateFilterCount; exports.formatPatterns = formatPatterns; exports.today = today; exports.fDateTime = fDateTime; exports.fDate = fDate; exports.fTime = fTime; exports.fTimestamp = fTimestamp; exports.fToNow = fToNow; exports.fIsBetween = fIsBetween; exports.fIsAfter = fIsAfter; exports.fIsSame = fIsSame; exports.fDateRangeShortLabel = fDateRangeShortLabel; exports.fAdd = fAdd; exports.fSub = fSub; exports.getEmptyObject = getEmptyObject; exports.useStableRowCount = useStableRowCount;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["c:\\Uttam\\Projects\\GNWebSoft.UI\\packages\\ui\\dist\\chunk-QLQ6OH25.cjs"],"names":[],"mappings":"AAAA;AACA,SAAS,YAAY,CAAC,EAAE;AACxB,EAAE,GAAG,CAAC,OAAO,OAAO,IAAI,YAAY,GAAG,MAAM,CAAC,UAAU,EAAE;AAC1D,IAAI,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC;AAC9B,EAAE;AACF,EAAE,OAAO,sCAAsC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG;AACxE,IAAI,MAAM,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC;AACpC,IAAI,MAAM,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACvC,IAAI,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AACzB,EAAE,CAAC,CAAC;AACJ;AACA,SAAS,qBAAqB,CAAC,MAAM,EAAE;AACvC,EAAE,MAAM,KAAK,EAAE,YAAY,CAAC,CAAC;AAC7B,EAAE,OAAO,OAAO,EAAE,CAAC,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAA;AACA;AACA;AACA;AACA;AACA,kBAAA;AACA;AACA;AACA;AACA;AACA,kBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAA;AACA;AACA;AACA;AACA;AACA,kBAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,c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kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,mBAAA;AACA,mBAAA;AACA,mBAAA;AACA,mBAAA;AACA,mBAAA;AACA,mBAAA;AACA,mBAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,wBAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,oBAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,sBAAA;AACA,sBAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,gBAAA;AACA,gBAAA;AACA,kBAAA;AACA,oBAAA;AACA,oBAAA;AACA,oBAAA;AACA,kBAAA;AACA,gBAAA;AACA,cAAA;AACA,8BAAA;AACA,gBAAA;AACA,gBAAA;AACA,kBAAA;AACA,kBAAA;AACA,oBAAA;AACA,oBAAA;AACA,oBAAA;AACA,kBAAA;AACA,kBAAA;AACA,oBAAA;AACA,oBAAA;AACA,oBAAA;AACA,kBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,wBAAA;AACA,wBAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,cAAA;AACA,cAAA;AACA,gBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,kBAAA;AACA,gBAAA;AACA,gBAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,sBAAA;AACA,wBAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,8BAAA;AACA,gBAAA;AACA,gCAAA;AACA,cAAA;AACA,cAAA;AACA,YAAA;AACA,UAAA;AACA,QAAA;AACA,wBAAA;AACA,MAAA;AACA,sBAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,oBAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,YAAA;AACA,UAAA;AACA,UAAA;AACA,QAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA;AACA;AACA;AACA,EAAA;AACA;AACA,EAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA;AACA,IAAA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA;AACA,IAAA;AACA;AACA,IAAA;AACA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,IAAA;AACA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,EAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,QAAA;AACA,QAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACA,IAAA;AACA,IAAA;AACA,EAAA;AACA,EAAA;AACA,IAAA;AACA,MAAA;AACA,QAAA;AACA,UAAA;AACA,UAAA;AACA,YAAA;AACA,cAAA;AACA,c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file":"C:\\Uttam\\Projects\\GNWebSoft.UI\\packages\\ui\\dist\\chunk-QLQ6OH25.cjs","sourcesContent":[null]}