@djangocfg/ext-payments 1.0.19 → 1.0.21

package/dist/api/index.cjs

@@ -0,0 +1,1738 @@
+'use strict';
+
+var api = require('@djangocfg/ext-base/api');
+var consola = require('consola');
+var pRetry = require('p-retry');
+var zod = require('zod');
+var useSWR = require('swr');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pRetry__default = /*#__PURE__*/_interopDefault(pRetry);
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+
+// 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, popular
+   * first
+   */
+  async currenciesList() {
+    const response = await this.client.request("GET", "/cfg/payments/currencies/");
+    return response;
+  }
+  /**
+   * Get currency estimate
+   * 
+   * Get estimated crypto amount for a given USD amount, including min amount
+   */
+  async currenciesEstimateRetrieve(...args) {
+    const code = args[0];
+    const isParamsObject = args.length === 2 && typeof args[1] === "object" && args[1] !== null && !Array.isArray(args[1]);
+    let params;
+    if (isParamsObject) {
+      params = args[1];
+    } else {
+      params = { amount: args[1] };
+    }
+    const response = await this.client.request("GET", `/cfg/payments/currencies/${code}/estimate/`, { params });
+    return response;
+  }
+  /**
+   * Get withdrawal estimate
+   * 
+   * Get estimated crypto amount for withdrawal with fee breakdown
+   */
+  async currenciesWithdrawalEstimateRetrieve(...args) {
+    const code = args[0];
+    const isParamsObject = args.length === 2 && typeof args[1] === "object" && args[1] !== null && !Array.isArray(args[1]);
+    let params;
+    if (isParamsObject) {
+      params = args[1];
+    } else {
+      params = { amount: args[1] };
+    }
+    const response = await this.client.request("GET", `/cfg/payments/currencies/${code}/withdrawal-estimate/`, { 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 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;
+  }
+  /**
+   * Create payment
+   * 
+   * Create a new payment with specified amount and currency
+   */
+  async paymentsCreateCreate(data) {
+    const response = await this.client.request("POST", "/cfg/payments/payments/create/", { body: data });
+    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;
+  }
+  /**
+   * ViewSet for withdrawal operations. Endpoints: - GET /withdrawals/ - List
+   * user's withdrawal requests - GET /withdrawals/{id}/ - Get withdrawal
+   * details - POST /withdrawals/create/ - Create withdrawal request - POST
+   * /withdrawals/{id}/cancel/ - Cancel pending withdrawal
+   */
+  async withdrawalsList(...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/withdrawals/", { params });
+    return response;
+  }
+  /**
+   * ViewSet for withdrawal operations. Endpoints: - GET /withdrawals/ - List
+   * user's withdrawal requests - GET /withdrawals/{id}/ - Get withdrawal
+   * details - POST /withdrawals/create/ - Create withdrawal request - POST
+   * /withdrawals/{id}/cancel/ - Cancel pending withdrawal
+   */
+  async withdrawalsRetrieve(id) {
+    const response = await this.client.request("GET", `/cfg/payments/withdrawals/${id}/`);
+    return response;
+  }
+  /**
+   * Cancel withdrawal request
+   * 
+   * Cancel a pending withdrawal request
+   */
+  async withdrawalsCancelCreate(id) {
+    const response = await this.client.request("POST", `/cfg/payments/withdrawals/${id}/cancel/`);
+    return response;
+  }
+  /**
+   * Create withdrawal request
+   * 
+   * Create a new withdrawal request (requires admin approval)
+   */
+  async withdrawalsCreateCreate(data) {
+    const response = await this.client.request("POST", "/cfg/payments/withdrawals/create/", { body: data });
+    return response;
+  }
+};
+
+// src/api/generated/ext_payments/http.ts
+var FetchAdapter = class {
+  async request(request) {
+    const { method, url, headers, body, params, formData, binaryBody } = 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 (binaryBody) {
+      finalHeaders["Content-Type"] = "application/octet-stream";
+      requestBody = binaryBody;
+    } 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;
+  tokenGetter = null;
+  // Sub-clients
+  ext_payments_payments;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter();
+    this.tokenGetter = options?.tokenGetter || null;
+    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;
+  }
+  /**
+   * Get the base URL for building streaming/download URLs.
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get JWT token for URL authentication (used in streaming endpoints).
+   * Returns null if no token getter is configured or no token is available.
+   */
+  getToken() {
+    return this.tokenGetter ? this.tokenGetter() : 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 && !options?.binaryBody && !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,
+        binaryBody: options?.binaryBody
+      });
+      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(logger) {
+    this.logger = logger;
+  }
+  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);
+    }
+  }
+};
+
+// src/api/generated/ext_payments/enums.ts
+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 || {});
+var WithdrawalDetailStatus = /* @__PURE__ */ ((WithdrawalDetailStatus2) => {
+  WithdrawalDetailStatus2["PENDING"] = "pending";
+  WithdrawalDetailStatus2["APPROVED"] = "approved";
+  WithdrawalDetailStatus2["PROCESSING"] = "processing";
+  WithdrawalDetailStatus2["COMPLETED"] = "completed";
+  WithdrawalDetailStatus2["REJECTED"] = "rejected";
+  WithdrawalDetailStatus2["CANCELLED"] = "cancelled";
+  return WithdrawalDetailStatus2;
+})(WithdrawalDetailStatus || {});
+var WithdrawalListStatus = /* @__PURE__ */ ((WithdrawalListStatus2) => {
+  WithdrawalListStatus2["PENDING"] = "pending";
+  WithdrawalListStatus2["APPROVED"] = "approved";
+  WithdrawalListStatus2["PROCESSING"] = "processing";
+  WithdrawalListStatus2["COMPLETED"] = "completed";
+  WithdrawalListStatus2["REJECTED"] = "rejected";
+  WithdrawalListStatus2["CANCELLED"] = "cancelled";
+  return WithdrawalListStatus2;
+})(WithdrawalListStatus || {});
+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.string().datetime({ offset: true }).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.string().datetime({ offset: true }),
+  completed_at: zod.z.string().datetime({ offset: true }).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 WithdrawalListSchema = 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_withdrawal_id: zod.z.string(),
+  amount_usd: zod.z.string(),
+  final_amount_usd: zod.z.string(),
+  currency_code: zod.z.string(),
+  currency_token: zod.z.string(),
+  status: zod.z.nativeEnum(WithdrawalListStatus),
+  status_display: zod.z.string(),
+  created_at: zod.z.string().datetime({ offset: true }),
+  completed_at: zod.z.string().datetime({ offset: true }).nullable()
+});
+
+// src/api/generated/ext_payments/_utils/schemas/PaginatedWithdrawalListList.schema.ts
+var PaginatedWithdrawalListListSchema = 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(WithdrawalListSchema)
+});
+var PaymentCreateRequestSchema = zod.z.object({
+  amount_usd: zod.z.string(),
+  currency_code: zod.z.string().min(1).max(20),
+  description: zod.z.string().max(500).optional()
+});
+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.union([zod.z.url(), zod.z.literal("")]).nullable(),
+  transaction_hash: zod.z.string().nullable(),
+  explorer_link: zod.z.string().nullable(),
+  confirmations_count: zod.z.int(),
+  expires_at: zod.z.string().datetime({ offset: true }).nullable(),
+  completed_at: zod.z.string().datetime({ offset: true }).nullable(),
+  created_at: zod.z.string().datetime({ offset: true }),
+  is_completed: zod.z.boolean(),
+  is_failed: zod.z.boolean(),
+  is_expired: zod.z.boolean(),
+  description: zod.z.string()
+});
+
+// src/api/generated/ext_payments/_utils/schemas/PaymentCreateResponse.schema.ts
+var PaymentCreateResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  payment: PaymentDetailSchema,
+  qr_code_url: zod.z.union([zod.z.url(), zod.z.literal("")]).nullable()
+});
+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.string().datetime({ offset: true })
+});
+var WithdrawalDetailSchema = 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_withdrawal_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(),
+  wallet_address: zod.z.string(),
+  network_fee_usd: zod.z.string(),
+  service_fee_usd: zod.z.string(),
+  total_fee_usd: zod.z.string(),
+  final_amount_usd: zod.z.string(),
+  crypto_amount: zod.z.string().nullable(),
+  status: zod.z.nativeEnum(WithdrawalDetailStatus),
+  status_display: zod.z.string(),
+  transaction_hash: zod.z.string().nullable(),
+  explorer_link: zod.z.string().nullable(),
+  admin_notes: zod.z.string(),
+  created_at: zod.z.string().datetime({ offset: true }),
+  approved_at: zod.z.string().datetime({ offset: true }).nullable(),
+  completed_at: zod.z.string().datetime({ offset: true }).nullable(),
+  rejected_at: zod.z.string().datetime({ offset: true }).nullable(),
+  cancelled_at: zod.z.string().datetime({ offset: true }).nullable()
+});
+
+// src/api/generated/ext_payments/_utils/schemas/WithdrawalCancelResponse.schema.ts
+var WithdrawalCancelResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  withdrawal: WithdrawalDetailSchema,
+  message: zod.z.string()
+});
+var WithdrawalCreateRequestSchema = zod.z.object({
+  amount_usd: zod.z.string(),
+  currency_code: zod.z.string().min(1).max(20),
+  wallet_address: zod.z.string().min(1).max(255)
+});
+var WithdrawalCreateResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  withdrawal: WithdrawalDetailSchema,
+  message: zod.z.string()
+});
+
+// src/api/generated/ext_payments/api-instance.ts
+var globalAPI = null;
+var autoConfigAttempted = false;
+function tryAutoConfigureFromEnv() {
+  if (autoConfigAttempted) return;
+  autoConfigAttempted = true;
+  if (globalAPI) return;
+  if (typeof process === "undefined" || !process.env) return;
+  const baseUrl = process.env.NEXT_PUBLIC_API_URL || process.env.VITE_API_URL || process.env.REACT_APP_API_URL || process.env.API_URL;
+  if (baseUrl) {
+    globalAPI = new API(baseUrl);
+  }
+}
+function getAPIInstance() {
+  tryAutoConfigureFromEnv();
+  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" })\n\nOr set environment variable: NEXT_PUBLIC_API_URL, VITE_API_URL, or REACT_APP_API_URL'
+    );
+  }
+  return globalAPI;
+}
+function configureAPI(config) {
+  globalAPI = new API(config.baseUrl, config.options);
+  if (config.token) {
+    globalAPI.setToken(config.token, config.refreshToken);
+  }
+  return globalAPI;
+}
+
+// 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 getPaymentsCurrenciesEstimateRetrieve(code, params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.currenciesEstimateRetrieve(code, params?.amount);
+  return response;
+}
+async function getPaymentsCurrenciesWithdrawalEstimateRetrieve(code, params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.currenciesWithdrawalEstimateRetrieve(code, params?.amount);
+  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(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.paymentsCreateCreate(data);
+  try {
+    return PaymentCreateResponseSchema.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;
+}
+async function getPaymentsWithdrawalsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.withdrawalsList(params?.page, params?.page_size);
+  try {
+    return PaginatedWithdrawalListListSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getPaymentsWithdrawalsList
+Path: /cfg/payments/withdrawals/
+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: "getPaymentsWithdrawalsList",
+            path: "/cfg/payments/withdrawals/",
+            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 getPaymentsWithdrawalsRetrieve(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.withdrawalsRetrieve(id);
+  try {
+    return WithdrawalDetailSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getPaymentsWithdrawalsRetrieve
+Path: /cfg/payments/withdrawals/{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: "getPaymentsWithdrawalsRetrieve",
+            path: "/cfg/payments/withdrawals/{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 createPaymentsWithdrawalsCancelCreate(id, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.withdrawalsCancelCreate(id);
+  try {
+    return WithdrawalCancelResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createPaymentsWithdrawalsCancelCreate
+Path: /cfg/payments/withdrawals/{id}/cancel/
+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: "createPaymentsWithdrawalsCancelCreate",
+            path: "/cfg/payments/withdrawals/{id}/cancel/",
+            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 createPaymentsWithdrawalsCreateCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_payments_payments.withdrawalsCreateCreate(data);
+  try {
+    return WithdrawalCreateResponseSchema.parse(response);
+  } catch (error) {
+    consola.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createPaymentsWithdrawalsCreateCreate
+Path: /cfg/payments/withdrawals/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: "createPaymentsWithdrawalsCreateCreate",
+            path: "/cfg/payments/withdrawals/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;
+  }
+}
+
+// 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 logger = options?.loggerConfig ? new APILogger(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter(logger);
+    this._loadTokensFromStorage();
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig,
+      tokenGetter: () => this.getToken()
+    });
+    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,
+      tokenGetter: () => this.getToken()
+    });
+    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";
+  }
+};
+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 usePaymentsCurrenciesEstimateRetrieve(code, params, client) {
+  return useSWR__default.default(
+    ["cfg-payments-currencies-estimate", code],
+    () => getPaymentsCurrenciesEstimateRetrieve(code, params, client)
+  );
+}
+function usePaymentsCurrenciesWithdrawalEstimateRetrieve(code, params, client) {
+  return useSWR__default.default(
+    ["cfg-payments-currencies-withdrawal-estimate", code],
+    () => getPaymentsCurrenciesWithdrawalEstimateRetrieve(code, params, 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 usePaymentsPaymentsStatusRetrieve(id, client) {
+  return useSWR__default.default(
+    ["cfg-payments-payments-statu", id],
+    () => getPaymentsPaymentsStatusRetrieve(id, client)
+  );
+}
+function useCreatePaymentsPaymentsCreateCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createPaymentsPaymentsCreateCreate(data, 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)
+  );
+}
+function usePaymentsWithdrawalsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-payments-withdrawals", params] : "cfg-payments-withdrawals",
+    () => getPaymentsWithdrawalsList(params, client)
+  );
+}
+function usePaymentsWithdrawalsRetrieve(id, client) {
+  return useSWR__default.default(
+    ["cfg-payments-withdrawal", id],
+    () => getPaymentsWithdrawalsRetrieve(id, client)
+  );
+}
+function useCreatePaymentsWithdrawalsCancelCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (id, client) => {
+    const result = await createPaymentsWithdrawalsCancelCreate(id, client);
+    mutate("cfg-payments-withdrawals-cancel");
+    return result;
+  };
+}
+function useCreatePaymentsWithdrawalsCreateCreate() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (data, client) => {
+    const result = await createPaymentsWithdrawalsCreateCreate(data, client);
+    mutate("cfg-payments-withdrawals");
+    return result;
+  };
+}
+
+// src/api/index.ts
+api.initializeExtensionAPI(configureAPI);
+var apiPayments = api.createExtensionAPI(API);
+
+exports.API = API;
+exports.BalanceSchema = BalanceSchema;
+exports.CurrencySchema = CurrencySchema;
+exports.PaginatedPaymentListListSchema = PaginatedPaymentListListSchema;
+exports.PaginatedWithdrawalListListSchema = PaginatedWithdrawalListListSchema;
+exports.PaymentCreateRequestSchema = PaymentCreateRequestSchema;
+exports.PaymentCreateResponseSchema = PaymentCreateResponseSchema;
+exports.PaymentDetailSchema = PaymentDetailSchema;
+exports.PaymentListSchema = PaymentListSchema;
+exports.TransactionSchema = TransactionSchema;
+exports.WithdrawalCancelResponseSchema = WithdrawalCancelResponseSchema;
+exports.WithdrawalCreateRequestSchema = WithdrawalCreateRequestSchema;
+exports.WithdrawalCreateResponseSchema = WithdrawalCreateResponseSchema;
+exports.WithdrawalDetailSchema = WithdrawalDetailSchema;
+exports.WithdrawalListSchema = WithdrawalListSchema;
+exports.apiPayments = apiPayments;
+exports.createPaymentsPaymentsConfirmCreate = createPaymentsPaymentsConfirmCreate;
+exports.createPaymentsPaymentsCreateCreate = createPaymentsPaymentsCreateCreate;
+exports.createPaymentsWithdrawalsCancelCreate = createPaymentsWithdrawalsCancelCreate;
+exports.createPaymentsWithdrawalsCreateCreate = createPaymentsWithdrawalsCreateCreate;
+exports.getPaymentsBalanceRetrieve = getPaymentsBalanceRetrieve;
+exports.getPaymentsCurrenciesEstimateRetrieve = getPaymentsCurrenciesEstimateRetrieve;
+exports.getPaymentsCurrenciesList = getPaymentsCurrenciesList;
+exports.getPaymentsCurrenciesWithdrawalEstimateRetrieve = getPaymentsCurrenciesWithdrawalEstimateRetrieve;
+exports.getPaymentsPaymentsList = getPaymentsPaymentsList;
+exports.getPaymentsPaymentsRetrieve = getPaymentsPaymentsRetrieve;
+exports.getPaymentsPaymentsStatusRetrieve = getPaymentsPaymentsStatusRetrieve;
+exports.getPaymentsTransactionsList = getPaymentsTransactionsList;
+exports.getPaymentsWithdrawalsList = getPaymentsWithdrawalsList;
+exports.getPaymentsWithdrawalsRetrieve = getPaymentsWithdrawalsRetrieve;
+exports.useCreatePaymentsPaymentsConfirmCreate = useCreatePaymentsPaymentsConfirmCreate;
+exports.useCreatePaymentsPaymentsCreateCreate = useCreatePaymentsPaymentsCreateCreate;
+exports.useCreatePaymentsWithdrawalsCancelCreate = useCreatePaymentsWithdrawalsCancelCreate;
+exports.useCreatePaymentsWithdrawalsCreateCreate = useCreatePaymentsWithdrawalsCreateCreate;
+exports.usePaymentsBalanceRetrieve = usePaymentsBalanceRetrieve;
+exports.usePaymentsCurrenciesEstimateRetrieve = usePaymentsCurrenciesEstimateRetrieve;
+exports.usePaymentsCurrenciesList = usePaymentsCurrenciesList;
+exports.usePaymentsCurrenciesWithdrawalEstimateRetrieve = usePaymentsCurrenciesWithdrawalEstimateRetrieve;
+exports.usePaymentsPaymentsList = usePaymentsPaymentsList;
+exports.usePaymentsPaymentsRetrieve = usePaymentsPaymentsRetrieve;
+exports.usePaymentsPaymentsStatusRetrieve = usePaymentsPaymentsStatusRetrieve;
+exports.usePaymentsTransactionsList = usePaymentsTransactionsList;
+exports.usePaymentsWithdrawalsList = usePaymentsWithdrawalsList;
+exports.usePaymentsWithdrawalsRetrieve = usePaymentsWithdrawalsRetrieve;