@djangocfg/ext-payments 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2590 @@
+'use strict';
+
+var consola = require('consola');
+var pRetry = require('p-retry');
+var zod = require('zod');
+var api = require('@djangocfg/ext-base/api');
+var react = require('react');
+var useSWR = require('swr');
+var jsxRuntime = require('react/jsx-runtime');
+var uiNextjs = require('@djangocfg/ui-nextjs');
+var lucideReact = require('lucide-react');
+var reactHookForm = require('react-hook-form');
+var zod$1 = require('@hookform/resolvers/zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pRetry__default = /*#__PURE__*/_interopDefault(pRetry);
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api/generated/ext_payments/ext_payments__payments/client.ts
+var ExtPaymentsPayments = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get user balance
+   * 
+   * Get current user balance and transaction statistics
+   */
+  async balanceRetrieve() {
+    const response = await this.client.request("GET", "/cfg/payments/balance/");
+    return response;
+  }
+  /**
+   * Get available currencies
+   * 
+   * Returns list of available currencies with token+network info
+   */
+  async currenciesList() {
+    const response = await this.client.request("GET", "/cfg/payments/currencies/");
+    return response;
+  }
+  /**
+   * ViewSet for payment operations. Endpoints: - GET /payments/ - List
+   * user's payments - GET /payments/{id}/ - Get payment details - POST
+   * /payments/create/ - Create new payment - GET /payments/{id}/status/ -
+   * Check payment status - POST /payments/{id}/confirm/ - Confirm payment
+   */
+  async paymentsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/payments/payments/", { params });
+    return response;
+  }
+  /**
+   * ViewSet for payment operations. Endpoints: - GET /payments/ - List
+   * user's payments - GET /payments/{id}/ - Get payment details - POST
+   * /payments/create/ - Create new payment - GET /payments/{id}/status/ -
+   * Check payment status - POST /payments/{id}/confirm/ - Confirm payment
+   */
+  async paymentsRetrieve(id) {
+    const response = await this.client.request("GET", `/cfg/payments/payments/${id}/`);
+    return response;
+  }
+  /**
+   * POST /api/v1/payments/{id}/confirm/ Confirm payment (user clicked "I
+   * have paid"). Checks status with provider and creates transaction if
+   * completed.
+   */
+  async paymentsConfirmCreate(id) {
+    const response = await this.client.request("POST", `/cfg/payments/payments/${id}/confirm/`);
+    return response;
+  }
+  /**
+   * GET /api/v1/payments/{id}/status/?refresh=true Check payment status
+   * (with optional refresh from provider). Query params: - refresh: boolean
+   * (default: false) - Force refresh from provider
+   */
+  async paymentsStatusRetrieve(id) {
+    const response = await this.client.request("GET", `/cfg/payments/payments/${id}/status/`);
+    return response.results || response;
+  }
+  /**
+   * POST /api/v1/payments/create/ Create new payment. Request body: {
+   * "amount_usd": "100.00", "currency_code": "USDTTRC20", "description":
+   * "Optional description" }
+   */
+  async paymentsCreateCreate() {
+    const response = await this.client.request("POST", "/cfg/payments/payments/create/");
+    return response;
+  }
+  /**
+   * Get user transactions
+   * 
+   * Get user transactions with pagination and filtering
+   */
+  async transactionsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { limit: args[0], offset: args[1], type: args[2] };
+    }
+    const response = await this.client.request("GET", "/cfg/payments/transactions/", { params });
+    return response;
+  }
+};
+
+// src/api/generated/ext_payments/ext_payments__payments/models.ts
+var models_exports = {};
+
+// src/api/generated/ext_payments/http.ts
+var FetchAdapter = class {
+  async request(request) {
+    const { method, url, headers, body, params, formData } = request;
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+    const finalHeaders = { ...headers };
+    let requestBody;
+    if (formData) {
+      requestBody = formData;
+    } else if (body) {
+      finalHeaders["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(body);
+    }
+    const response = await fetch(finalUrl, {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: "include"
+      // Include Django session cookies
+    });
+    let data = null;
+    const contentType = response.headers.get("content-type");
+    if (response.status !== 204 && contentType?.includes("application/json")) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
+  }
+};
+
+// src/api/generated/ext_payments/errors.ts
+var APIError = class extends Error {
+  constructor(statusCode, statusText, response, url, message) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.response = response;
+    this.url = url;
+    this.name = "APIError";
+  }
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details() {
+    if (typeof this.response === "object" && this.response !== null) {
+      return this.response;
+    }
+    return null;
+  }
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors() {
+    const details = this.details;
+    if (!details) return null;
+    const fieldErrors = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage() {
+    const details = this.details;
+    if (!details) return this.message;
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(", ") : String(details.detail);
+    }
+    if (details.message) {
+      return String(details.message);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // Helper methods for common HTTP status codes
+  get isValidationError() {
+    return this.statusCode === 400;
+  }
+  get isAuthError() {
+    return this.statusCode === 401;
+  }
+  get isPermissionError() {
+    return this.statusCode === 403;
+  }
+  get isNotFoundError() {
+    return this.statusCode === 404;
+  }
+  get isServerError() {
+    return this.statusCode >= 500 && this.statusCode < 600;
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message, url, originalError) {
+    super(message);
+    this.url = url;
+    this.originalError = originalError;
+    this.name = "NetworkError";
+  }
+};
+var DEFAULT_CONFIG = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger = class {
+  config;
+  consola;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || consola.createConsola({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * Log request
+   */
+  logRequest(request) {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) {
+      this.consola.debug("Headers:", this.filterHeaders(headers));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * Log response
+   */
+  logResponse(request, response) {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+    if (this.config.logBodies && data) {
+      this.consola.debug("Response:", data);
+    }
+  }
+  /**
+   * Log error
+   */
+  logError(request, error) {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(
+      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
+    );
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  \u2022 ${field}: ${err}`);
+        });
+      });
+    }
+  }
+  /**
+   * Log general info
+   */
+  info(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+  /**
+   * Log warning
+   */
+  warn(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.warn(message, ...args);
+  }
+  /**
+   * Log error
+   */
+  error(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+  /**
+   * Log debug
+   */
+  debug(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+  /**
+   * Log success
+   */
+  success(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag) {
+    return this.consola.withTag(tag);
+  }
+};
+new APILogger();
+var DEFAULT_RETRY_CONFIG = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: () => {
+  }
+};
+function shouldRetry(error) {
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof APIError) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+async function withRetry(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  return pRetry__default.default(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry(error)) {
+          throw new pRetry.AbortError(error);
+        }
+        throw error;
+      }
+    },
+    {
+      retries: finalConfig.retries,
+      factor: finalConfig.factor,
+      minTimeout: finalConfig.minTimeout,
+      maxTimeout: finalConfig.maxTimeout,
+      randomize: finalConfig.randomize,
+      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
+        const pRetryError = error;
+        finalConfig.onFailedAttempt({
+          error: pRetryError,
+          attemptNumber: pRetryError.attemptNumber,
+          retriesLeft: pRetryError.retriesLeft
+        });
+      } : void 0
+    }
+  );
+}
+
+// src/api/generated/ext_payments/client.ts
+var APIClient = class {
+  baseUrl;
+  httpClient;
+  logger = null;
+  retryConfig = null;
+  // Sub-clients
+  ext_payments_payments;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter();
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger(options.loggerConfig);
+    }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
+    }
+    this.ext_payments_payments = new ExtPaymentsPayments(this);
+  }
+  /**
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
+   */
+  getCsrfToken() {
+    const name = "csrftoken";
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop()?.split(";").shift() || null;
+    }
+    return null;
+  }
+  /**
+   * Make HTTP request with Django CSRF and session handling.
+   * Automatically retries on network errors and 5xx server errors.
+   */
+  async request(method, path, options) {
+    if (this.retryConfig) {
+      return withRetry(() => this._makeRequest(method, path, options), {
+        ...this.retryConfig,
+        onFailedAttempt: (info) => {
+          if (this.logger) {
+            this.logger.warn(
+              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} for ${method} ${path}: ${info.error.message}`
+            );
+          }
+          this.retryConfig?.onFailedAttempt?.(info);
+        }
+      });
+    }
+    return this._makeRequest(method, path, options);
+  }
+  /**
+   * Internal request method (without retry wrapper).
+   * Used by request() method with optional retry logic.
+   */
+  async _makeRequest(method, path, options) {
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+    const startTime = Date.now();
+    const headers = {
+      ...options?.headers || {}
+    };
+    if (!options?.formData && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.logger) {
+      this.logger.logRequest({
+        method,
+        url,
+        headers,
+        body: options?.formData || options?.body,
+        timestamp: startTime
+      });
+    }
+    try {
+      const response = await this.httpClient.request({
+        method,
+        url,
+        headers,
+        params: options?.params,
+        body: options?.body,
+        formData: options?.formData
+      });
+      const duration = Date.now() - startTime;
+      if (response.status >= 400) {
+        const error = new APIError(
+          response.status,
+          response.statusText,
+          response.data,
+          url
+        );
+        if (this.logger) {
+          this.logger.logError(
+            {
+              method,
+              url,
+              headers,
+              body: options?.formData || options?.body,
+              timestamp: startTime
+            },
+            {
+              message: error.message,
+              statusCode: response.status,
+              duration,
+              timestamp: Date.now()
+            }
+          );
+        }
+        throw error;
+      }
+      if (this.logger) {
+        this.logger.logResponse(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      return response.data;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (error instanceof APIError) {
+        throw error;
+      }
+      const isCORSError = error instanceof TypeError && (error.message.toLowerCase().includes("cors") || error.message.toLowerCase().includes("failed to fetch") || error.message.toLowerCase().includes("network request failed"));
+      if (this.logger) {
+        if (isCORSError) {
+          this.logger.error(`\u{1F6AB} CORS Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error(`  \u2192 Configure security_domains parameter on the server`);
+        } else {
+          this.logger.error(`\u26A0\uFE0F  Network Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (typeof window !== "undefined") {
+        try {
+          if (isCORSError) {
+            window.dispatchEvent(new CustomEvent("cors-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          } else {
+            window.dispatchEvent(new CustomEvent("network-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          }
+        } catch (eventError) {
+        }
+      }
+      const networkError = error instanceof Error ? new NetworkError(error.message, url, error) : new NetworkError("Unknown error", url);
+      if (this.logger) {
+        this.logger.logError(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            message: networkError.message,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      throw networkError;
+    }
+  }
+};
+
+// src/api/generated/ext_payments/storage.ts
+var LocalStorageAdapter = class {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+        return value;
+      }
+      this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+    } catch (error) {
+      this.logger?.error("LocalStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.removeItem failed:", error);
+    }
+  }
+};
+var CookieStorageAdapter = class {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    try {
+      if (typeof document === "undefined") {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+        return null;
+      }
+      const value = `; ${document.cookie}`;
+      const parts = value.split(`; ${key}=`);
+      if (parts.length === 2) {
+        const result = parts.pop()?.split(";").shift() || null;
+        this.logger?.debug(`CookieStorage.getItem("${key}"): ${result ? "found" : "not found"}`);
+        return result;
+      }
+      this.logger?.debug(`CookieStorage.getItem("${key}"): not found`);
+    } catch (error) {
+      this.logger?.error("CookieStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof document !== "undefined") {
+        document.cookie = `${key}=${value}; path=/; max-age=31536000`;
+        this.logger?.debug(`CookieStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+      }
+    } catch (error) {
+      this.logger?.error("CookieStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof document !== "undefined") {
+        document.cookie = `${key}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+        this.logger?.debug(`CookieStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+      }
+    } catch (error) {
+      this.logger?.error("CookieStorage.removeItem failed:", error);
+    }
+  }
+};
+var MemoryStorageAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    const value = this.storage.get(key) || null;
+    this.logger?.debug(`MemoryStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+    return value;
+  }
+  setItem(key, value) {
+    this.storage.set(key, value);
+    this.logger?.debug(`MemoryStorage.setItem("${key}"): success`);
+  }
+  removeItem(key) {
+    this.storage.delete(key);
+    this.logger?.debug(`MemoryStorage.removeItem("${key}"): success`);
+  }
+};
+
+// src/api/generated/ext_payments/enums.ts
+var enums_exports = {};
+__export(enums_exports, {
+  PaymentDetailStatus: () => PaymentDetailStatus,
+  PaymentListStatus: () => PaymentListStatus,
+  TransactionTransactionType: () => TransactionTransactionType
+});
+var PaymentDetailStatus = /* @__PURE__ */ ((PaymentDetailStatus2) => {
+  PaymentDetailStatus2["PENDING"] = "pending";
+  PaymentDetailStatus2["CONFIRMING"] = "confirming";
+  PaymentDetailStatus2["CONFIRMED"] = "confirmed";
+  PaymentDetailStatus2["COMPLETED"] = "completed";
+  PaymentDetailStatus2["PARTIALLY_PAID"] = "partially_paid";
+  PaymentDetailStatus2["FAILED"] = "failed";
+  PaymentDetailStatus2["EXPIRED"] = "expired";
+  PaymentDetailStatus2["CANCELLED"] = "cancelled";
+  return PaymentDetailStatus2;
+})(PaymentDetailStatus || {});
+var PaymentListStatus = /* @__PURE__ */ ((PaymentListStatus2) => {
+  PaymentListStatus2["PENDING"] = "pending";
+  PaymentListStatus2["CONFIRMING"] = "confirming";
+  PaymentListStatus2["CONFIRMED"] = "confirmed";
+  PaymentListStatus2["COMPLETED"] = "completed";
+  PaymentListStatus2["PARTIALLY_PAID"] = "partially_paid";
+  PaymentListStatus2["FAILED"] = "failed";
+  PaymentListStatus2["EXPIRED"] = "expired";
+  PaymentListStatus2["CANCELLED"] = "cancelled";
+  return PaymentListStatus2;
+})(PaymentListStatus || {});
+var TransactionTransactionType = /* @__PURE__ */ ((TransactionTransactionType2) => {
+  TransactionTransactionType2["DEPOSIT"] = "deposit";
+  TransactionTransactionType2["WITHDRAWAL"] = "withdrawal";
+  TransactionTransactionType2["PAYMENT"] = "payment";
+  TransactionTransactionType2["REFUND"] = "refund";
+  TransactionTransactionType2["FEE"] = "fee";
+  TransactionTransactionType2["BONUS"] = "bonus";
+  TransactionTransactionType2["ADJUSTMENT"] = "adjustment";
+  return TransactionTransactionType2;
+})(TransactionTransactionType || {});
+
+// src/api/generated/ext_payments/_utils/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  BalanceSchema: () => BalanceSchema,
+  CurrencySchema: () => CurrencySchema,
+  PaginatedPaymentListListSchema: () => PaginatedPaymentListListSchema,
+  PaymentDetailSchema: () => PaymentDetailSchema,
+  PaymentListSchema: () => PaymentListSchema,
+  TransactionSchema: () => TransactionSchema
+});
+var BalanceSchema = zod.z.object({
+  balance_usd: zod.z.string(),
+  balance_display: zod.z.string(),
+  total_deposited: zod.z.string(),
+  total_withdrawn: zod.z.string(),
+  last_transaction_at: zod.z.iso.datetime().nullable()
+});
+var CurrencySchema = zod.z.object({
+  code: zod.z.string(),
+  name: zod.z.string(),
+  token: zod.z.string(),
+  network: zod.z.string().nullable(),
+  display_name: zod.z.string(),
+  symbol: zod.z.string(),
+  decimal_places: zod.z.int(),
+  is_active: zod.z.boolean(),
+  min_amount_usd: zod.z.string(),
+  sort_order: zod.z.int()
+});
+var PaymentListSchema = zod.z.object({
+  id: zod.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  internal_payment_id: zod.z.string(),
+  amount_usd: zod.z.string(),
+  currency_code: zod.z.string(),
+  currency_token: zod.z.string(),
+  status: zod.z.nativeEnum(PaymentListStatus),
+  status_display: zod.z.string(),
+  created_at: zod.z.iso.datetime(),
+  completed_at: zod.z.iso.datetime().nullable()
+});
+
+// src/api/generated/ext_payments/_utils/schemas/PaginatedPaymentListList.schema.ts
+var PaginatedPaymentListListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(PaymentListSchema)
+});
+var PaymentDetailSchema = zod.z.object({
+  id: zod.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  internal_payment_id: zod.z.string(),
+  amount_usd: zod.z.string(),
+  currency_code: zod.z.string(),
+  currency_name: zod.z.string(),
+  currency_token: zod.z.string(),
+  currency_network: zod.z.string(),
+  pay_amount: zod.z.string().nullable(),
+  actual_amount: zod.z.string().nullable(),
+  actual_amount_usd: zod.z.string().nullable(),
+  status: zod.z.nativeEnum(PaymentDetailStatus),
+  status_display: zod.z.string(),
+  pay_address: zod.z.string().nullable(),
+  qr_code_url: zod.z.string().nullable(),
+  payment_url: zod.z.url().nullable(),
+  transaction_hash: zod.z.string().nullable(),
+  explorer_link: zod.z.string().nullable(),
+  confirmations_count: zod.z.int(),
+  expires_at: zod.z.iso.datetime().nullable(),
+  completed_at: zod.z.iso.datetime().nullable(),
+  created_at: zod.z.iso.datetime(),
+  is_completed: zod.z.boolean(),
+  is_failed: zod.z.boolean(),
+  is_expired: zod.z.boolean(),
+  description: zod.z.string()
+});
+var TransactionSchema = zod.z.object({
+  id: zod.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  transaction_type: zod.z.nativeEnum(TransactionTransactionType),
+  type_display: zod.z.string(),
+  amount_usd: zod.z.string(),
+  amount_display: zod.z.string(),
+  balance_after: zod.z.string(),
+  payment_id: zod.z.string().nullable(),
+  description: zod.z.string(),
+  created_at: zod.z.iso.datetime()
+});
+
+// src/api/generated/ext_payments/validation-events.ts
+function dispatchValidationError(detail) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    const event = new CustomEvent("zod-validation-error", {
+      detail,
+      bubbles: true,
+      cancelable: false
+    });
+    window.dispatchEvent(event);
+  } catch (error) {
+    console.warn("Failed to dispatch validation error event:", error);
+  }
+}
+function onValidationError(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const handler = (event) => {
+    if (event instanceof CustomEvent) {
+      callback(event.detail);
+    }
+  };
+  window.addEventListener("zod-validation-error", handler);
+  return () => {
+    window.removeEventListener("zod-validation-error", handler);
+  };
+}
+function formatZodError(error) {
+  const issues = error.issues.map((issue, index) => {
+    const path = issue.path.join(".") || "root";
+    const parts = [`${index + 1}. ${path}: ${issue.message}`];
+    if ("expected" in issue && issue.expected) {
+      parts.push(`   Expected: ${issue.expected}`);
+    }
+    if ("received" in issue && issue.received) {
+      parts.push(`   Received: ${issue.received}`);
+    }
+    return parts.join("\n");
+  });
+  return issues.join("\n");
+}
+
+// src/api/generated/ext_payments/_utils/fetchers/index.ts
+var fetchers_exports = {};
+__export(fetchers_exports, {
+  createPaymentsPaymentsConfirmCreate: () => createPaymentsPaymentsConfirmCreate,
+  createPaymentsPaymentsCreateCreate: () => createPaymentsPaymentsCreateCreate,
+  getPaymentsBalanceRetrieve: () => getPaymentsBalanceRetrieve,
+  getPaymentsCurrenciesList: () => getPaymentsCurrenciesList,
+  getPaymentsPaymentsList: () => getPaymentsPaymentsList,
+  getPaymentsPaymentsRetrieve: () => getPaymentsPaymentsRetrieve,
+  getPaymentsPaymentsStatusRetrieve: () => getPaymentsPaymentsStatusRetrieve,
+  getPaymentsTransactionsList: () => getPaymentsTransactionsList
+});
+
+// src/api/generated/ext_payments/api-instance.ts
+var globalAPI = null;
+function getAPIInstance() {
+  if (!globalAPI) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\nExample:\n  import { configureAPI } from "./api-instance"\n  configureAPI({ baseUrl: "https://api.example.com" })'
+    );
+  }
+  return globalAPI;
+}
+function isAPIConfigured() {
+  return globalAPI !== null;
+}
+function configureAPI(config) {
+  globalAPI = new API(config.baseUrl, config.options);
+  if (config.token) {
+    globalAPI.setToken(config.token, config.refreshToken);
+  }
+  return globalAPI;
+}
+function reconfigureAPI(updates) {
+  const instance = getAPIInstance();
+  if (updates.baseUrl) {
+    instance.setBaseUrl(updates.baseUrl);
+  }
+  if (updates.token) {
+    instance.setToken(updates.token, updates.refreshToken);
+  }
+  return instance;
+}
+function clearAPITokens() {
+  const instance = getAPIInstance();
+  instance.clearTokens();
+}
+function resetAPI() {
+  if (globalAPI) {
+    globalAPI.clearTokens();
+  }
+  globalAPI = null;
+}
+
+// src/api/generated/ext_payments/_utils/fetchers/ext_payments__payments.ts
+async function getPaymentsBalanceRetrieve(client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.balanceRetrieve();
+  try {
+    return BalanceSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getPaymentsBalanceRetrieve
+Path: /cfg/payments/balance/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getPaymentsBalanceRetrieve",
+            path: "/cfg/payments/balance/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getPaymentsCurrenciesList(client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.currenciesList();
+  return response;
+}
+async function getPaymentsPaymentsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.paymentsList(params?.page, params?.page_size);
+  try {
+    return PaginatedPaymentListListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getPaymentsPaymentsList
+Path: /cfg/payments/payments/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getPaymentsPaymentsList",
+            path: "/cfg/payments/payments/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getPaymentsPaymentsRetrieve(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.paymentsRetrieve(id);
+  try {
+    return PaymentDetailSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getPaymentsPaymentsRetrieve
+Path: /cfg/payments/payments/{id}/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getPaymentsPaymentsRetrieve",
+            path: "/cfg/payments/payments/{id}/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createPaymentsPaymentsConfirmCreate(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.paymentsConfirmCreate(id);
+  try {
+    return PaymentListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createPaymentsPaymentsConfirmCreate
+Path: /cfg/payments/payments/{id}/confirm/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createPaymentsPaymentsConfirmCreate",
+            path: "/cfg/payments/payments/{id}/confirm/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getPaymentsPaymentsStatusRetrieve(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.paymentsStatusRetrieve(id);
+  try {
+    return PaymentListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getPaymentsPaymentsStatusRetrieve
+Path: /cfg/payments/payments/{id}/status/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getPaymentsPaymentsStatusRetrieve",
+            path: "/cfg/payments/payments/{id}/status/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createPaymentsPaymentsCreateCreate(client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.paymentsCreateCreate();
+  try {
+    return PaymentListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createPaymentsPaymentsCreateCreate
+Path: /cfg/payments/payments/create/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createPaymentsPaymentsCreateCreate",
+            path: "/cfg/payments/payments/create/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getPaymentsTransactionsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.transactionsList(params?.limit, params?.offset, params?.type);
+  return response;
+}
+
+// src/api/generated/ext_payments/index.ts
+var TOKEN_KEY = "auth_token";
+var REFRESH_TOKEN_KEY = "refresh_token";
+var API = class {
+  baseUrl;
+  _client;
+  _token = null;
+  _refreshToken = null;
+  storage;
+  options;
+  // Sub-clients
+  ext_payments_payments;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger2 = options?.loggerConfig ? new APILogger(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter(logger2);
+    this._loadTokensFromStorage();
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.ext_payments_payments = this._client.ext_payments_payments;
+  }
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  _reinitClients() {
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.ext_payments_payments = this._client.ext_payments_payments;
+  }
+  _injectAuthHeader() {
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async (method, path, options) => {
+      const token = this.getToken();
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...options?.headers || {},
+          ...token ? { "Authorization": `Bearer ${token}` } : {}
+        }
+      };
+      return originalRequest(method, path, mergedOptions);
+    };
+  }
+  /**
+   * Get current JWT token
+   */
+  getToken() {
+    return this.storage.getItem(TOKEN_KEY);
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  /**
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
+   */
+  setToken(token, refreshToken) {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+    this._reinitClients();
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+    this._reinitClients();
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.getToken();
+  }
+  /**
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
+   */
+  setBaseUrl(url) {
+    this.baseUrl = url;
+    this._reinitClients();
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
+   */
+  getSchemaPath() {
+    return "./schema.json";
+  }
+};
+var apiPayments = api.createExtensionAPI(API);
+function usePaymentsBalanceRetrieve(client) {
+  return useSWR__default.default(
+    "cfg-payments-balance",
+    () => getPaymentsBalanceRetrieve(client)
+  );
+}
+function usePaymentsCurrenciesList(client) {
+  return useSWR__default.default(
+    "cfg-payments-currencies",
+    () => getPaymentsCurrenciesList(client)
+  );
+}
+function usePaymentsPaymentsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-payments-payments", params] : "cfg-payments-payments",
+    () => getPaymentsPaymentsList(params, client)
+  );
+}
+function usePaymentsPaymentsRetrieve(id, client) {
+  return useSWR__default.default(
+    ["cfg-payments-payment", id],
+    () => getPaymentsPaymentsRetrieve(id, client)
+  );
+}
+function useCreatePaymentsPaymentsConfirmCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (id, client) => {
+    const result = await createPaymentsPaymentsConfirmCreate(id, client);
+    mutate("cfg-payments-payments-confirm");
+    return result;
+  };
+}
+function useCreatePaymentsPaymentsCreateCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (client) => {
+    const result = await createPaymentsPaymentsCreateCreate(client);
+    mutate("cfg-payments-payments");
+    return result;
+  };
+}
+function usePaymentsTransactionsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-payments-transactions", params] : "cfg-payments-transactions",
+    () => getPaymentsTransactionsList(params, client)
+  );
+}
+var PaymentsContext = react.createContext(void 0);
+function PaymentsProvider({ children }) {
+  const {
+    data: payments,
+    error: paymentsError,
+    isLoading: isLoadingPayments,
+    mutate: mutatePayments
+  } = usePaymentsPaymentsList({ page: 1, page_size: 1 }, apiPayments);
+  const refreshPayments = async () => {
+    await mutatePayments();
+  };
+  const createPaymentMutation = useCreatePaymentsPaymentsCreateCreate();
+  const confirmPaymentMutation = useCreatePaymentsPaymentsConfirmCreate();
+  const getPayment = async (id) => {
+    return getPaymentsPaymentsRetrieve(id, apiPayments);
+  };
+  const createPayment = async () => {
+    const result = await createPaymentMutation(apiPayments);
+    await refreshPayments();
+    return result;
+  };
+  const confirmPayment = async (id) => {
+    const result = await confirmPaymentMutation(id, apiPayments);
+    await refreshPayments();
+    return result;
+  };
+  const checkPaymentStatus = async (id) => {
+    return getPaymentsPaymentsStatusRetrieve(id, apiPayments);
+  };
+  const value = {
+    payments,
+    isLoadingPayments,
+    paymentsError,
+    refreshPayments,
+    getPayment,
+    createPayment,
+    confirmPayment,
+    checkPaymentStatus
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(PaymentsContext.Provider, { value, children });
+}
+function usePaymentsContext() {
+  const context = react.useContext(PaymentsContext);
+  if (!context) {
+    throw new Error("usePaymentsContext must be used within PaymentsProvider");
+  }
+  return context;
+}
+react.createContext(void 0);
+react.createContext(void 0);
+var OverviewContext = react.createContext(void 0);
+function OverviewProvider({ children }) {
+  const swrConfig = {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    revalidateIfStale: false
+  };
+  const {
+    data: balance,
+    error: balanceError,
+    isLoading: isLoadingBalance,
+    mutate: mutateBalance
+  } = usePaymentsBalanceRetrieve(apiPayments);
+  const {
+    data: payments,
+    error: paymentsError,
+    isLoading: isLoadingPayments,
+    mutate: mutatePayments
+  } = usePaymentsPaymentsList({}, apiPayments);
+  const {
+    data: transactions,
+    error: transactionsError,
+    isLoading: isLoadingTransactions,
+    mutate: mutateTransactions
+  } = usePaymentsTransactionsList({}, apiPayments);
+  const createPaymentMutation = useCreatePaymentsPaymentsCreateCreate();
+  const isLoadingOverview = isLoadingBalance || isLoadingPayments || isLoadingTransactions;
+  const overviewError = balanceError || paymentsError || transactionsError;
+  const refreshBalance = async () => {
+    await mutateBalance();
+  };
+  const refreshPayments = async () => {
+    await mutatePayments();
+  };
+  const refreshTransactions = async () => {
+    await mutateTransactions();
+  };
+  const refreshOverview = async () => {
+    await Promise.all([
+      mutateBalance(),
+      mutatePayments(),
+      mutateTransactions()
+    ]);
+  };
+  const createPayment = async () => {
+    const result = await createPaymentMutation(apiPayments);
+    await refreshOverview();
+    return result;
+  };
+  const value = {
+    balance,
+    isLoadingBalance,
+    balanceError,
+    refreshBalance,
+    payments,
+    isLoadingPayments,
+    paymentsError,
+    refreshPayments,
+    transactions,
+    isLoadingTransactions,
+    transactionsError,
+    refreshTransactions,
+    createPayment,
+    isLoadingOverview,
+    overviewError,
+    refreshOverview
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(useSWR.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ jsxRuntime.jsx(OverviewContext.Provider, { value, children }) });
+}
+function useOverviewContext() {
+  const context = react.useContext(OverviewContext);
+  if (!context) {
+    throw new Error("useOverviewContext must be used within OverviewProvider");
+  }
+  return context;
+}
+var RootPaymentsContext = react.createContext(void 0);
+function RootPaymentsProvider({ children }) {
+  const {
+    data: currencies,
+    error: currenciesError,
+    isLoading: isLoadingCurrencies,
+    mutate: mutateCurrencies
+  } = usePaymentsCurrenciesList(apiPayments);
+  const refreshCurrencies = async () => {
+    await mutateCurrencies();
+  };
+  const value = {
+    currencies,
+    isLoadingCurrencies,
+    currenciesError,
+    refreshCurrencies
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(RootPaymentsContext.Provider, { value, children });
+}
+function useRootPaymentsContext() {
+  const context = react.useContext(RootPaymentsContext);
+  if (!context) {
+    throw new Error("useRootPaymentsContext must be used within RootPaymentsProvider");
+  }
+  return context;
+}
+
+// src/layouts/PaymentsLayout/events.ts
+var PAYMENT_EVENTS = {
+  OPEN_CREATE_PAYMENT_DIALOG: "payments:open-create-payment",
+  OPEN_PAYMENT_DETAILS_DIALOG: "payments:open-payment-details",
+  CLOSE_DIALOG: "payments:close-dialog"
+};
+var openCreatePaymentDialog = () => {
+  window.dispatchEvent(new Event(PAYMENT_EVENTS.OPEN_CREATE_PAYMENT_DIALOG));
+};
+var openPaymentDetailsDialog = (id) => {
+  window.dispatchEvent(
+    new CustomEvent(PAYMENT_EVENTS.OPEN_PAYMENT_DETAILS_DIALOG, {
+      detail: { id }
+    })
+  );
+};
+var closePaymentsDialog = () => {
+  window.dispatchEvent(new Event(PAYMENT_EVENTS.CLOSE_DIALOG));
+};
+var BalanceCard = () => {
+  const {
+    balance,
+    isLoadingBalance,
+    refreshBalance
+  } = useOverviewContext();
+  const formatCurrency = (amount) => {
+    if (amount === null || amount === void 0) return "$0.00";
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2
+    }).format(amount);
+  };
+  const formatDate = (dateStr) => {
+    if (!dateStr) return "No transactions yet";
+    try {
+      return new Date(dateStr).toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric"
+      });
+    } catch {
+      return "Invalid date";
+    }
+  };
+  if (isLoadingBalance) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Wallet, { className: "h-5 w-5" }),
+          "Account Balance"
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-8 w-20" })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardContent, { className: "space-y-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-10 w-32" }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-4 w-48" })
+      ] })
+    ] });
+  }
+  const balanceData = balance?.balance || balance;
+  const amountUsd = balanceData?.amount_usd ?? 0;
+  const totalDeposited = balanceData?.total_deposited ?? 0;
+  const totalWithdrawn = balanceData?.total_withdrawn ?? 0;
+  const lastTransactionAt = balanceData?.last_transaction_at;
+  const isEmpty = amountUsd === 0 && totalDeposited === 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Wallet, { className: "h-5 w-5" }),
+        "Account Balance"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Button, { variant: "ghost", size: "sm", onClick: refreshBalance, children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-4 w-4" }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { size: "sm", onClick: () => openCreatePaymentDialog(), children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+          "Add Funds"
+        ] })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-4xl font-bold", children: formatCurrency(amountUsd) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-sm text-muted-foreground mt-1", children: [
+          "Available balance \u2022 Last updated ",
+          formatDate(lastTransactionAt)
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-2 gap-4 pt-4 border-t", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-muted-foreground", children: "Total Deposited" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-lg font-semibold text-green-600", children: formatCurrency(totalDeposited) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-xs text-muted-foreground", children: "Total Withdrawn" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-lg font-semibold text-red-600", children: formatCurrency(totalWithdrawn) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: !isEmpty ? "default" : "secondary", children: !isEmpty ? "Active" : "New Account" }),
+        isEmpty && /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: "outline", children: "Empty Balance" })
+      ] })
+    ] })
+  ] });
+};
+var RecentPayments = () => {
+  const { payments, isLoadingPayments } = useOverviewContext();
+  const formatCurrency = (amount) => {
+    if (amount === null || amount === void 0) return "$0.00";
+    const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2
+    }).format(numAmount);
+  };
+  const getRelativeTime = (date) => {
+    if (!date) return "N/A";
+    const now = /* @__PURE__ */ new Date();
+    const target = new Date(date);
+    const diffInSeconds = Math.floor((now.getTime() - target.getTime()) / 1e3);
+    if (diffInSeconds < 60) return "Just now";
+    if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`;
+    if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`;
+    return `${Math.floor(diffInSeconds / 86400)}d ago`;
+  };
+  const getStatusVariant = (status) => {
+    switch (status?.toLowerCase()) {
+      case "completed":
+      case "success":
+        return "default";
+      case "pending":
+      case "confirming":
+        return "secondary";
+      case "failed":
+      case "error":
+      case "expired":
+        return "destructive";
+      default:
+        return "outline";
+    }
+  };
+  if (isLoadingPayments) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "h-5 w-5" }),
+        "Recent Payments"
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardContent, { className: "space-y-3", children: Array.from({ length: 5 }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between p-3 border rounded-sm", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-4 w-32" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-3 w-24" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-6 w-16" })
+      ] }, i)) })
+    ] });
+  }
+  const recentPaymentsList = payments?.results?.slice(0, 5) || [];
+  return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "h-5 w-5" }),
+        "Recent Payments"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { variant: "ghost", size: "sm", children: [
+        "View All",
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ExternalLink, { className: "h-4 w-4 ml-2" })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardContent, { children: recentPaymentsList.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center py-8 text-muted-foreground", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "h-12 w-12 mx-auto mb-4 opacity-50" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { children: "No recent payments" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm mt-2", children: "Create your first payment to get started" })
+    ] }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-3", children: recentPaymentsList.map((payment) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "flex items-center justify-between p-3 border rounded-sm hover:bg-accent cursor-pointer transition-colors",
+        onClick: () => openPaymentDetailsDialog(String(payment.id)),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium", children: formatCurrency(payment.amount_usd) }),
+              /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: getStatusVariant(payment.status), className: "text-xs", children: payment.status })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-sm text-muted-foreground", children: [
+              getRelativeTime(payment.created_at),
+              " \u2022 ",
+              payment.currency_code || "USD"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ExternalLink, { className: "h-4 w-4 text-muted-foreground" })
+        ]
+      },
+      payment.id
+    )) }) })
+  ] });
+};
+var OverviewView = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-6", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid gap-6 lg:grid-cols-2", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(BalanceCard, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(RecentPayments, {})
+  ] }) });
+};
+var PaymentsList = () => {
+  const pagination = uiNextjs.useDRFPagination(1, 20);
+  const {
+    data: payments,
+    error,
+    isLoading: isLoadingPayments,
+    mutate: refreshPayments
+  } = usePaymentsPaymentsList(pagination.params, apiPayments);
+  const paymentsList = payments?.results || [];
+  payments?.count || 0;
+  const [searchTerm, setSearchTerm] = react.useState("");
+  const [statusFilter, setStatusFilter] = react.useState("all");
+  const formatCurrency = (amount) => {
+    if (amount === null || amount === void 0) return "$0.00";
+    const numAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2
+    }).format(numAmount);
+  };
+  const getRelativeTime = (date) => {
+    if (!date) return "N/A";
+    const now = /* @__PURE__ */ new Date();
+    const target = new Date(date);
+    const diffInSeconds = Math.floor((now.getTime() - target.getTime()) / 1e3);
+    if (diffInSeconds < 60) return "Just now";
+    if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`;
+    if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`;
+    return `${Math.floor(diffInSeconds / 86400)}d ago`;
+  };
+  const getStatusVariant = (status) => {
+    switch (status?.toLowerCase()) {
+      case "completed":
+      case "success":
+        return "default";
+      case "pending":
+      case "confirming":
+        return "secondary";
+      case "failed":
+      case "error":
+      case "expired":
+        return "destructive";
+      default:
+        return "outline";
+    }
+  };
+  const handleSearch = (value) => {
+    setSearchTerm(value);
+  };
+  const handleStatusFilter = (status) => {
+    setStatusFilter(status);
+  };
+  const filteredPayments = paymentsList.filter((payment) => {
+    const matchesSearch = searchTerm ? payment.id?.toLowerCase().includes(searchTerm.toLowerCase()) || payment.status?.toLowerCase().includes(searchTerm.toLowerCase()) || payment.currency_code?.toLowerCase().includes(searchTerm.toLowerCase()) : true;
+    const matchesStatus = statusFilter !== "all" ? payment.status?.toLowerCase() === statusFilter.toLowerCase() : true;
+    return matchesSearch && matchesStatus;
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Payment History" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { variant: "outline", size: "sm", onClick: () => refreshPayments(), disabled: isLoadingPayments, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: `h-4 w-4 mr-2 ${isLoadingPayments ? "animate-spin" : ""}` }),
+          "Refresh"
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { size: "sm", onClick: () => openCreatePaymentDialog(), children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+          "New Payment"
+        ] })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col sm:flex-row gap-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Search, { className: "absolute left-3 top-1/2 transform -translate-y-1/2 h-4 w-4 text-muted-foreground" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            uiNextjs.Input,
+            {
+              placeholder: "Search by ID, status, or currency...",
+              value: searchTerm,
+              onChange: (e) => handleSearch(e.target.value),
+              className: "pl-10"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Select, { value: statusFilter, onValueChange: handleStatusFilter, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.SelectTrigger, { className: "w-full sm:w-48", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Filter, { className: "h-4 w-4 mr-2" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectValue, { placeholder: "Filter by status" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.SelectContent, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "all", children: "All Statuses" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "completed", children: "Completed" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "pending", children: "Pending" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "confirming", children: "Confirming" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "failed", children: "Failed" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "expired", children: "Expired" })
+          ] })
+        ] })
+      ] }),
+      isLoadingPayments ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-3", children: Array.from({ length: 5 }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between p-4 border rounded-sm", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-4 w-32" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-3 w-24" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-6 w-16" })
+      ] }, i)) }) : filteredPayments.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center py-12", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-16 h-16 mx-auto mb-4 bg-muted rounded-full flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Search, { className: "w-8 h-8 text-muted-foreground" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold mb-2", children: "No Payments Found" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground mb-4", children: searchTerm || statusFilter !== "all" ? "No payments match your current filters" : "You haven't made any payments yet" }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { onClick: () => openCreatePaymentDialog(), children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+          "Create Payment"
+        ] })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-md border", children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Table, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TableRow, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Date" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Amount" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Currency" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Status" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Provider" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Payment ID" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { className: "text-right", children: "Actions" })
+          ] }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableBody, { children: filteredPayments.map((payment) => /* @__PURE__ */ jsxRuntime.jsxs(
+            uiNextjs.TableRow,
+            {
+              className: "cursor-pointer hover:bg-accent",
+              onClick: () => openPaymentDetailsDialog(String(payment.id)),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium", children: payment.created_at ? new Date(payment.created_at).toLocaleDateString() : "N/A" }),
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-muted-foreground", children: getRelativeTime(payment.created_at) })
+                ] }) }),
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "font-mono font-semibold", children: formatCurrency(payment.amount_usd) }),
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { children: /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: "outline", children: payment.currency_code || "USD" }) }),
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { children: /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: getStatusVariant(payment.status), children: payment.status }) }),
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "text-sm text-muted-foreground", children: "NowPayments" }),
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "font-mono text-sm text-muted-foreground", children: payment.id ? `${payment.id.toString().slice(0, 8)}...` : "N/A" }),
+                /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "text-right", children: /* @__PURE__ */ jsxRuntime.jsx(
+                  uiNextjs.Button,
+                  {
+                    variant: "ghost",
+                    size: "sm",
+                    onClick: (e) => {
+                      e.stopPropagation();
+                      openPaymentDetailsDialog(String(payment.id));
+                    },
+                    children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ExternalLink, { className: "h-4 w-4" })
+                  }
+                ) })
+              ]
+            },
+            payment.id
+          )) })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          uiNextjs.StaticPagination,
+          {
+            data: payments,
+            onPageChange: pagination.setPage,
+            className: "mt-4"
+          }
+        )
+      ] })
+    ] })
+  ] });
+};
+var PaymentsView = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-6", children: /* @__PURE__ */ jsxRuntime.jsx(PaymentsList, {}) });
+};
+var TransactionsList = () => {
+  const {
+    transactions,
+    isLoadingTransactions,
+    refreshTransactions
+  } = useOverviewContext();
+  const [searchTerm, setSearchTerm] = react.useState("");
+  const [typeFilter, setTypeFilter] = react.useState("all");
+  const transactionsList = transactions?.results || transactions?.transactions || [];
+  const formatCurrency = (amount) => {
+    if (amount === null || amount === void 0) return "$0.00";
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2
+    }).format(amount);
+  };
+  const formatDate = (date) => {
+    if (!date) return "N/A";
+    try {
+      return new Date(date).toLocaleString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+    } catch {
+      return "Invalid date";
+    }
+  };
+  const getRelativeTime = (date) => {
+    if (!date) return "N/A";
+    const now = /* @__PURE__ */ new Date();
+    const target = new Date(date);
+    const diffInSeconds = Math.floor((now.getTime() - target.getTime()) / 1e3);
+    if (diffInSeconds < 60) return "Just now";
+    if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`;
+    if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`;
+    return `${Math.floor(diffInSeconds / 86400)}d ago`;
+  };
+  const getTypeVariant = (type) => {
+    switch (type?.toLowerCase()) {
+      case "deposit":
+      case "credit":
+        return "default";
+      case "withdrawal":
+      case "debit":
+        return "destructive";
+      default:
+        return "outline";
+    }
+  };
+  const getTypeIcon = (type) => {
+    const isDeposit = type?.toLowerCase() === "deposit" || type?.toLowerCase() === "credit";
+    return isDeposit ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ArrowDownLeft, { className: "h-4 w-4 text-green-600" }) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ArrowUpRight, { className: "h-4 w-4 text-red-600" });
+  };
+  const handleSearch = async (value) => {
+    setSearchTerm(value);
+    await refreshTransactions();
+  };
+  const handleTypeFilter = async (type) => {
+    setTypeFilter(type);
+    await refreshTransactions();
+  };
+  const filteredTransactions = transactionsList.filter((transaction) => {
+    const matchesSearch = searchTerm ? transaction.id?.toString().toLowerCase().includes(searchTerm.toLowerCase()) || transaction.description?.toLowerCase().includes(searchTerm.toLowerCase()) || transaction.type?.toLowerCase().includes(searchTerm.toLowerCase()) : true;
+    const matchesType = typeFilter !== "all" ? transaction.type?.toLowerCase() === typeFilter.toLowerCase() : true;
+    return matchesSearch && matchesType;
+  });
+  if (isLoadingTransactions) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "h-5 w-5" }),
+        "Transaction History"
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardContent, { className: "space-y-3", children: Array.from({ length: 5 }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between p-4 border rounded-sm", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-4 w-32" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-3 w-24" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-6 w-16" })
+      ] }, i)) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Card, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardTitle, { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "h-5 w-5" }),
+        "Transaction History"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { variant: "outline", size: "sm", onClick: refreshTransactions, disabled: isLoadingTransactions, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: `h-4 w-4 mr-2 ${isLoadingTransactions ? "animate-spin" : ""}` }),
+        "Refresh"
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.CardContent, { className: "space-y-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col sm:flex-row gap-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Search, { className: "absolute left-3 top-1/2 transform -translate-y-1/2 h-4 w-4 text-muted-foreground" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            uiNextjs.Input,
+            {
+              placeholder: "Search by ID, description, or type...",
+              value: searchTerm,
+              onChange: (e) => handleSearch(e.target.value),
+              className: "pl-10"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Select, { value: typeFilter, onValueChange: handleTypeFilter, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.SelectTrigger, { className: "w-full sm:w-48", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Filter, { className: "h-4 w-4 mr-2" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectValue, { placeholder: "Filter by type" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.SelectContent, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "all", children: "All Types" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "deposit", children: "Deposits" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: "withdrawal", children: "Withdrawals" })
+          ] })
+        ] })
+      ] }),
+      filteredTransactions.length === 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-center py-12", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-16 h-16 mx-auto mb-4 bg-muted rounded-full flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "w-8 h-8 text-muted-foreground" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold mb-2", children: "No Transactions Found" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground", children: searchTerm || typeFilter !== "all" ? "No transactions match your current filters" : "You don't have any transactions yet" })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "rounded-md border", children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Table, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHeader, { children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TableRow, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Date & Time" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Type" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Amount" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Balance After" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Description" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableHead, { children: "Reference" })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableBody, { children: filteredTransactions.map((transaction, index) => {
+          const isDeposit = transaction.type?.toLowerCase() === "deposit" || transaction.type?.toLowerCase() === "credit";
+          return /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TableRow, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-medium", children: formatDate(transaction.created_at || transaction.timestamp) }),
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-muted-foreground", children: getRelativeTime(transaction.created_at || transaction.timestamp) })
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+              getTypeIcon(transaction.type),
+              /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: getTypeVariant(transaction.type), children: transaction.type || "Unknown" })
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "font-mono font-semibold", children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: isDeposit ? "text-green-600" : "text-red-600", children: [
+              isDeposit ? "+" : "-",
+              formatCurrency(Math.abs(transaction.amount || transaction.amount_usd || 0))
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "font-mono", children: formatCurrency(transaction.balance_after || 0) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "text-sm", children: transaction.description || transaction.note || "No description" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TableCell, { className: "font-mono text-sm text-muted-foreground", children: transaction.reference || transaction.payment_id ? `${(transaction.reference || transaction.payment_id).toString().slice(0, 8)}...` : "N/A" })
+          ] }, transaction.id || index);
+        }) })
+      ] }) })
+    ] })
+  ] });
+};
+var TransactionsView = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-6", children: /* @__PURE__ */ jsxRuntime.jsx(TransactionsList, {}) });
+};
+var isDevelopment = process.env.NODE_ENV === "development";
+var logger = consola.createConsola({
+  level: isDevelopment ? 4 : 1
+}).withTag("ext-payments");
+var paymentsLogger = logger;
+var PaymentCreateSchema = zod.z.object({
+  amount_usd: zod.z.number().min(0.01, "Amount must be at least $0.01"),
+  currency_code: zod.z.string().min(1, "Please select a currency")
+});
+var CreatePaymentDialog = () => {
+  const [open, setOpen] = react.useState(false);
+  const [isSubmitting, setIsSubmitting] = react.useState(false);
+  const { createPayment } = usePaymentsContext();
+  const { currencies, isLoadingCurrencies } = useRootPaymentsContext();
+  const form = reactHookForm.useForm({
+    resolver: zod$1.zodResolver(PaymentCreateSchema),
+    defaultValues: {
+      amount_usd: 10,
+      currency_code: "USDT"
+    }
+  });
+  const currenciesList = react.useMemo(() => {
+    const data = currencies?.currencies || currencies?.results || currencies || [];
+    return Array.isArray(data) ? data : [];
+  }, [currencies]);
+  const currencyOptions = react.useMemo(() => {
+    return currenciesList.filter((curr) => curr.is_enabled !== false).map((curr) => ({
+      code: curr.code || curr.currency_code || curr.symbol,
+      name: curr.name || curr.code || curr.currency_code,
+      usd_rate: curr.usd_rate || curr.rate || 1,
+      network: curr.network || null
+    }));
+  }, [currenciesList]);
+  const calculateCryptoAmount = react.useMemo(() => {
+    const amountUsd = form.watch("amount_usd");
+    const currencyCode = form.watch("currency_code");
+    const currency = currencyOptions.find((c) => c.code === currencyCode);
+    if (!currency || !currency.usd_rate || !amountUsd) {
+      return null;
+    }
+    const cryptoAmount = amountUsd / currency.usd_rate;
+    return {
+      amount: cryptoAmount,
+      currency: currency.code,
+      rate: currency.usd_rate,
+      network: currency.network
+    };
+  }, [form.watch("amount_usd"), form.watch("currency_code"), currencyOptions]);
+  react.useEffect(() => {
+    const handleOpen = () => setOpen(true);
+    const handleClose2 = () => setOpen(false);
+    window.addEventListener(PAYMENT_EVENTS.OPEN_CREATE_PAYMENT_DIALOG, handleOpen);
+    window.addEventListener(PAYMENT_EVENTS.CLOSE_DIALOG, handleClose2);
+    return () => {
+      window.removeEventListener(PAYMENT_EVENTS.OPEN_CREATE_PAYMENT_DIALOG, handleOpen);
+      window.removeEventListener(PAYMENT_EVENTS.CLOSE_DIALOG, handleClose2);
+    };
+  }, []);
+  const handleClose = () => {
+    setOpen(false);
+    form.reset();
+  };
+  react.useEffect(() => {
+    if (currencyOptions.length > 0 && !form.getValues("currency_code")) {
+      form.setValue("currency_code", currencyOptions[0].code);
+    }
+  }, [currencyOptions, form]);
+  const handleSubmit = async (data) => {
+    try {
+      setIsSubmitting(true);
+      const result = await createPayment();
+      handleClose();
+      closePaymentsDialog();
+      const paymentData = result;
+      const paymentId = paymentData?.payment?.id || paymentData?.id;
+      if (paymentId) {
+        openPaymentDetailsDialog(String(paymentId));
+      }
+    } catch (error) {
+      paymentsLogger.error("Failed to create payment:", error);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Dialog, { open, onOpenChange: (isOpen) => !isOpen && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogContent, { className: "sm:max-w-md", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogHeader, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogTitle, { children: "Create Payment" }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogDescription, { children: "Create a new payment to add funds to your account." })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Form, { ...form, children: /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: form.handleSubmit(handleSubmit), className: "space-y-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.FormField,
+        {
+          control: form.control,
+          name: "amount_usd",
+          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.FormItem, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormLabel, { children: "Amount (USD)" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormControl, { children: /* @__PURE__ */ jsxRuntime.jsx(
+              uiNextjs.Input,
+              {
+                type: "number",
+                step: "0.01",
+                min: "0.01",
+                placeholder: "10.00",
+                ...field,
+                onChange: (e) => field.onChange(parseFloat(e.target.value) || 0)
+              }
+            ) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormDescription, { children: "The amount you want to pay in USD." }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormMessage, {})
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.FormField,
+        {
+          control: form.control,
+          name: "currency_code",
+          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.FormItem, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormLabel, { children: "Currency" }),
+            /* @__PURE__ */ jsxRuntime.jsxs(
+              uiNextjs.Select,
+              {
+                onValueChange: field.onChange,
+                defaultValue: field.value,
+                disabled: isLoadingCurrencies,
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormControl, { children: /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectTrigger, { children: /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectValue, { placeholder: "Select currency..." }) }) }),
+                  /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectContent, { children: currencyOptions.map((curr) => /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.SelectItem, { value: curr.code, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+                    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TokenIcon, { symbol: curr.code, size: 16 }),
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { children: curr.code }),
+                    curr.network && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-muted-foreground", children: [
+                      "(",
+                      curr.network,
+                      ")"
+                    ] })
+                  ] }) }, curr.code)) })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormDescription, { children: "The cryptocurrency to use for payment." }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormMessage, {})
+          ] })
+        }
+      ),
+      calculateCryptoAmount && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "rounded-sm bg-muted p-4 space-y-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "You will send" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TokenIcon, { symbol: calculateCryptoAmount.currency, size: 16 }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-mono font-semibold", children: [
+              calculateCryptoAmount.amount.toFixed(8),
+              " ",
+              calculateCryptoAmount.currency
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "You will receive" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-lg font-bold", children: [
+            "$",
+            form.watch("amount_usd")?.toFixed(2),
+            " USD"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between text-xs", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: "Rate" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium", children: [
+            "1 ",
+            calculateCryptoAmount.currency,
+            " = $",
+            calculateCryptoAmount.rate?.toFixed(2)
+          ] })
+        ] }),
+        calculateCryptoAmount.network && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-t pt-3", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "Network" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm font-medium", children: calculateCryptoAmount.network })
+        ] }) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogFooter, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Button, { type: "button", variant: "outline", onClick: handleClose, disabled: isSubmitting, children: "Cancel" }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Button, { type: "submit", disabled: isSubmitting || currencyOptions.length === 0, children: isSubmitting ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-4 w-4 mr-2 animate-spin" }),
+          "Creating..."
+        ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+          "Create Payment"
+        ] }) })
+      ] })
+    ] }) })
+  ] }) });
+};
+var PaymentDetailsDialog = () => {
+  const [open, setOpen] = react.useState(false);
+  const [paymentId, setPaymentId] = react.useState(null);
+  const [timeLeft, setTimeLeft] = react.useState("");
+  const shouldFetch = open && !!paymentId;
+  const { data: payment, isLoading, error, mutate } = usePaymentsPaymentsRetrieve(
+    shouldFetch ? paymentId : "",
+    apiPayments
+  );
+  react.useEffect(() => {
+    const handleOpen = (event) => {
+      const customEvent = event;
+      setPaymentId(customEvent.detail.id);
+      setOpen(true);
+    };
+    const handleClose2 = () => {
+      setOpen(false);
+      setPaymentId(null);
+    };
+    window.addEventListener(PAYMENT_EVENTS.OPEN_PAYMENT_DETAILS_DIALOG, handleOpen);
+    window.addEventListener(PAYMENT_EVENTS.CLOSE_DIALOG, handleClose2);
+    return () => {
+      window.removeEventListener(PAYMENT_EVENTS.OPEN_PAYMENT_DETAILS_DIALOG, handleOpen);
+      window.removeEventListener(PAYMENT_EVENTS.CLOSE_DIALOG, handleClose2);
+    };
+  }, []);
+  const handleClose = () => {
+    setOpen(false);
+    setPaymentId(null);
+  };
+  react.useEffect(() => {
+    if (!payment?.expires_at) return;
+    const updateTimeLeft = () => {
+      const now = (/* @__PURE__ */ new Date()).getTime();
+      const expires = new Date(payment.expires_at).getTime();
+      const diff = expires - now;
+      if (diff <= 0) {
+        setTimeLeft("Expired");
+        return;
+      }
+      const hours = Math.floor(diff / (1e3 * 60 * 60));
+      const minutes = Math.floor(diff % (1e3 * 60 * 60) / (1e3 * 60));
+      const seconds = Math.floor(diff % (1e3 * 60) / 1e3);
+      setTimeLeft(`${hours}h ${minutes}m ${seconds}s`);
+    };
+    updateTimeLeft();
+    const interval = setInterval(updateTimeLeft, 1e3);
+    return () => clearInterval(interval);
+  }, [payment?.expires_at]);
+  const getStatusInfo = () => {
+    switch (payment?.status?.toLowerCase()) {
+      case "pending":
+        return { icon: lucideReact.Clock, color: "text-yellow-500", bg: "bg-yellow-500/10" };
+      case "completed":
+      case "success":
+        return { icon: lucideReact.CheckCircle2, color: "text-green-500", bg: "bg-green-500/10" };
+      case "failed":
+      case "error":
+        return { icon: lucideReact.XCircle, color: "text-red-500", bg: "bg-red-500/10" };
+      case "expired":
+        return { icon: lucideReact.AlertCircle, color: "text-gray-500", bg: "bg-gray-500/10" };
+      case "confirming":
+        return { icon: lucideReact.RefreshCw, color: "text-blue-500", bg: "bg-blue-500/10" };
+      default:
+        return { icon: lucideReact.Clock, color: "text-gray-500", bg: "bg-gray-500/10" };
+    }
+  };
+  if (!open) return null;
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Dialog, { open, onOpenChange: (isOpen) => !isOpen && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogContent, { className: "sm:max-w-lg", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogHeader, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogTitle, { children: "Payment Details" }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogDescription, { children: "Loading payment information..." })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center py-12", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-8 w-8 animate-spin text-muted-foreground" }) })
+    ] }) });
+  }
+  if (shouldFetch && !isLoading && (error || !payment)) {
+    return /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Dialog, { open, onOpenChange: (isOpen) => !isOpen && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogContent, { className: "sm:max-w-lg", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogHeader, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogTitle, { children: "Payment Details" }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogDescription, { children: "Failed to load payment information" })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center justify-center py-12 space-y-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.XCircle, { className: "h-12 w-12 text-destructive" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: error ? `Error: ${error}` : "Payment not found" }),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Button, { onClick: () => mutate(), children: "Try Again" })
+      ] })
+    ] }) });
+  }
+  const statusInfo = getStatusInfo();
+  const StatusIcon = statusInfo.icon;
+  const qrCodeUrl = payment.pay_address ? `https://api.qrserver.com/v1/create-qr-code/?size=200x200&data=${encodeURIComponent(payment.pay_address)}` : null;
+  return /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Dialog, { open, onOpenChange: (isOpen) => !isOpen && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogContent, { className: "sm:max-w-lg", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogHeader, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogTitle, { children: "Payment Details" }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogDescription, { children: "Send cryptocurrency to complete your payment" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex items-center gap-3 p-4 rounded-sm ${statusInfo.bg}`, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(StatusIcon, { className: `h-5 w-5 ${statusInfo.color}` }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-semibold capitalize", children: payment.status }),
+          payment.status === "pending" && timeLeft && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-sm text-muted-foreground", children: [
+            "Expires in ",
+            timeLeft
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between p-4 bg-muted rounded-sm", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "Amount to send" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TokenIcon, { symbol: String(payment.currency_code || "BTC"), size: 20 }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-mono font-bold text-lg", children: [
+              payment.pay_amount || "0.00000000",
+              " ",
+              payment.currency_code
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-4", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "Equivalent to" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-semibold text-lg", children: [
+            "$",
+            parseFloat(payment.amount_usd || "0").toFixed(2),
+            " USD"
+          ] })
+        ] }),
+        payment.internal_payment_id && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-4", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "Payment Order #" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-mono font-medium", children: payment.internal_payment_id })
+        ] }),
+        payment.currency_network && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-4", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-muted-foreground", children: "Network" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium", children: payment.currency_network })
+        ] })
+      ] }),
+      qrCodeUrl && payment.status === "pending" && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-center p-6 bg-white rounded-sm", children: /* @__PURE__ */ jsxRuntime.jsx("img", { src: qrCodeUrl, alt: "Payment QR Code", className: "w-48 h-48" }) }),
+      payment.pay_address && payment.status === "pending" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-sm font-medium", children: "Payment Address" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 p-3 bg-muted rounded-sm font-mono text-sm break-all", children: payment.pay_address }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CopyButton, { value: payment.pay_address, variant: "outline" })
+        ] })
+      ] }),
+      payment.transaction_hash && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-sm font-medium", children: "Transaction Hash" }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-3 bg-muted rounded-sm font-mono text-sm break-all", children: payment.transaction_hash })
+      ] }),
+      payment.payment_url && payment.status === "pending" && /* @__PURE__ */ jsxRuntime.jsxs(
+        uiNextjs.Button,
+        {
+          variant: "outline",
+          className: "w-full",
+          onClick: () => window.open(payment.payment_url, "_blank"),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ExternalLink, { className: "h-4 w-4 mr-2" }),
+            "Open in Payment Provider"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "pt-4 border-t space-y-2 text-xs text-muted-foreground", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Payment ID" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-mono", children: payment.id })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Created" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: new Date(payment.created_at).toLocaleString() })
+        ] }),
+        payment.confirmations_count !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Confirmations" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: payment.confirmations_count })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogFooter, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Button, { variant: "outline", onClick: handleClose, children: "Close" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { onClick: () => mutate(), variant: "ghost", size: "sm", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.RefreshCw, { className: "h-4 w-4 mr-2" }),
+        "Refresh"
+      ] })
+    ] })
+  ] }) });
+};
+var PaymentsLayout = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx(RootPaymentsProvider, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-full p-6 space-y-6", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-3xl font-bold tracking-tight", children: "Payments" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground", children: "Manage your payments, balance, and transaction history" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Tabs, { defaultValue: "overview", className: "space-y-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TabsList, { className: "inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TabsTrigger, { value: "overview", className: "inline-flex items-center gap-2 px-3 py-1.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Wallet, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden sm:inline", children: "Overview" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TabsTrigger, { value: "payments", className: "inline-flex items-center gap-2 px-3 py-1.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CreditCard, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden sm:inline", children: "Payments" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.TabsTrigger, { value: "transactions", className: "inline-flex items-center gap-2 px-3 py-1.5", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.History, { className: "h-4 w-4" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden sm:inline", children: "Transactions" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TabsContent, { value: "overview", className: "space-y-6", children: /* @__PURE__ */ jsxRuntime.jsx(OverviewProvider, { children: /* @__PURE__ */ jsxRuntime.jsxs(PaymentsProvider, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(OverviewView, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(CreatePaymentDialog, {})
+      ] }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TabsContent, { value: "payments", className: "space-y-6", children: /* @__PURE__ */ jsxRuntime.jsxs(PaymentsProvider, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(PaymentsView, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(CreatePaymentDialog, {})
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.TabsContent, { value: "transactions", className: "space-y-6", children: /* @__PURE__ */ jsxRuntime.jsx(OverviewProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(TransactionsView, {}) }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(PaymentDetailsDialog, {})
+  ] }) });
+};
+
+exports.API = API;
+exports.APIClient = APIClient;
+exports.APIError = APIError;
+exports.APILogger = APILogger;
+exports.BalanceSchema = BalanceSchema;
+exports.CookieStorageAdapter = CookieStorageAdapter;
+exports.CurrencySchema = CurrencySchema;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
+exports.Enums = enums_exports;
+exports.ExtPaymentsPaymentsTypes = models_exports;
+exports.FetchAdapter = FetchAdapter;
+exports.Fetchers = fetchers_exports;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.NetworkError = NetworkError;
+exports.PAYMENT_EVENTS = PAYMENT_EVENTS;
+exports.PaginatedPaymentListListSchema = PaginatedPaymentListListSchema;
+exports.PaymentDetailSchema = PaymentDetailSchema;
+exports.PaymentListSchema = PaymentListSchema;
+exports.PaymentsLayout = PaymentsLayout;
+exports.REFRESH_TOKEN_KEY = REFRESH_TOKEN_KEY;
+exports.Schemas = schemas_exports;
+exports.TOKEN_KEY = TOKEN_KEY;
+exports.TransactionSchema = TransactionSchema;
+exports.apiPayments = apiPayments;
+exports.clearAPITokens = clearAPITokens;
+exports.closePaymentsDialog = closePaymentsDialog;
+exports.configureAPI = configureAPI;
+exports.createPaymentsPaymentsConfirmCreate = createPaymentsPaymentsConfirmCreate;
+exports.createPaymentsPaymentsCreateCreate = createPaymentsPaymentsCreateCreate;
+exports.dispatchValidationError = dispatchValidationError;
+exports.formatZodError = formatZodError;
+exports.getAPIInstance = getAPIInstance;
+exports.getPaymentsBalanceRetrieve = getPaymentsBalanceRetrieve;
+exports.getPaymentsCurrenciesList = getPaymentsCurrenciesList;
+exports.getPaymentsPaymentsList = getPaymentsPaymentsList;
+exports.getPaymentsPaymentsRetrieve = getPaymentsPaymentsRetrieve;
+exports.getPaymentsPaymentsStatusRetrieve = getPaymentsPaymentsStatusRetrieve;
+exports.getPaymentsTransactionsList = getPaymentsTransactionsList;
+exports.isAPIConfigured = isAPIConfigured;
+exports.onValidationError = onValidationError;
+exports.openCreatePaymentDialog = openCreatePaymentDialog;
+exports.openPaymentDetailsDialog = openPaymentDetailsDialog;
+exports.reconfigureAPI = reconfigureAPI;
+exports.resetAPI = resetAPI;
+exports.shouldRetry = shouldRetry;
+exports.withRetry = withRetry;