@wirexapp/wpay-baas-sdk 0.1.6 → 0.1.8

package/dist/chunk-D2YHFKQI.js

@@ -0,0 +1,1364 @@
+import { AuthenticationError, ValidationError } from './chunk-YXNNTBO5.js';
+
+// src/modules/api/baas/activity/activity.service.ts
+var ActivityService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves activity feed with optional pagination and filters.
+   */
+  async getFeed(request) {
+    this.logger?.info("Fetching activity feed...");
+    const params = {};
+    if (request?.page_number !== void 0) params.page_number = request.page_number;
+    if (request?.page_size !== void 0) params.page_size = request.page_size;
+    if (request?.sort) params.sort = request.sort;
+    if (request?.subject) params.subject = request.subject;
+    if (request?.types?.length) params.types = request.types;
+    const response = await this.httpClient.get("api/v1/activity/feed", {
+      params: Object.keys(params).length ? params : void 0
+    });
+    this.logger?.info("Activity feed fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves a single activity item by id.
+   */
+  async getById(request) {
+    this.logger?.info("Fetching activity by id...");
+    const response = await this.httpClient.get(
+      `api/v1/activity/single/${encodeURIComponent(request.id)}`
+    );
+    this.logger?.info("Activity fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves full statement for the given date range (Unix timestamps).
+   */
+  async getFullStatement(request) {
+    this.logger?.info("Fetching full statement...");
+    const response = await this.httpClient.post(
+      "api/v1/activity/statement/full",
+      request
+    );
+    this.logger?.info("Full statement fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves requested ERC withdrawals for the authenticated account.
+   */
+  async getRequestedErcWithdrawals() {
+    this.logger?.info("Fetching requested ERC withdrawals...");
+    const response = await this.httpClient.get("api/v1/withdrawal/requests");
+    this.logger?.info("Requested ERC withdrawals fetched successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/bank/bank.service.ts
+var BankService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves a list of bank accounts that belong to the user.
+   */
+  async getAccounts(request) {
+    this.logger?.info("Fetching bank accounts...");
+    const params = {};
+    if (request?.page_number !== void 0) params.page_number = request.page_number;
+    if (request?.page_size !== void 0) params.page_size = request.page_size;
+    if (request?.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/bank/accounts", {
+      params: Object.keys(params).length ? params : void 0
+    });
+    this.logger?.info("Bank accounts fetched successfully");
+    return response;
+  }
+  /**
+   * Activates bank account details for the specified account type.
+   */
+  async activateAccount(request) {
+    this.logger?.info("Activating bank account...");
+    const response = await this.httpClient.post(
+      "api/v1/bank/accounts",
+      request
+    );
+    this.logger?.info("Bank account activated successfully");
+    return response;
+  }
+  /**
+   * Estimates the amounts that would be charged for a bank transfer according to the current market rates.
+   */
+  async estimateTransfer(request) {
+    this.logger?.info("Estimating bank transfer...");
+    const response = await this.httpClient.post(
+      "api/v1/bank/transfer/estimate",
+      request
+    );
+    this.logger?.info("Bank transfer estimated successfully");
+    return response;
+  }
+  /**
+   * Executes the bank transfer either according to the estimation made previously or using current market rates.
+   */
+  async executeTransfer(request) {
+    this.logger?.info("Executing bank transfer...");
+    const response = await this.httpClient.post(
+      "api/v1/bank/transfer",
+      request
+    );
+    this.logger?.info("Bank transfer executed successfully");
+    return response;
+  }
+  /**
+   * Estimates the amounts for a bank transfer via specified corridor.
+   */
+  async estimateCorridorTransferV2(corridor, request) {
+    this.logger?.info("Estimating corridor transfer...");
+    const response = await this.httpClient.post(
+      `api/v2/bank/${encodeURIComponent(corridor)}/estimate`,
+      request
+    );
+    this.logger?.info("Corridor transfer estimated successfully");
+    return response;
+  }
+  /**
+   * Executes transfer using estimation_id. All recipient details resolved from stored estimation.
+   */
+  async executeCorridorTransferV2(corridor, request) {
+    this.logger?.info("Executing corridor transfer...");
+    const response = await this.httpClient.post(
+      `api/v2/bank/${encodeURIComponent(corridor)}`,
+      request
+    );
+    this.logger?.info("Corridor transfer executed successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/cards/cards.service.ts
+var CardsService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves list of cards that belong to the user.
+   */
+  async getCards(request) {
+    this.logger?.info("Fetching cards...");
+    const params = {};
+    if (request?.page_number !== void 0) params.page_number = request.page_number;
+    if (request?.page_size !== void 0) params.page_size = request.page_size;
+    if (request?.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/cards", {
+      params: Object.keys(params).length ? params : void 0
+    });
+    this.logger?.info("Cards fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves a page of card transactions associated with the user.
+   */
+  async getCardTransactions(request) {
+    this.logger?.info("Fetching card transactions...");
+    const params = {};
+    if (request?.page_number !== void 0) params.page_number = request.page_number;
+    if (request?.page_size !== void 0) params.page_size = request.page_size;
+    if (request?.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/transactions/card", {
+      params: Object.keys(params).length ? params : void 0
+    });
+    this.logger?.info("Card transactions fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves single card by its id.
+   */
+  async getCard(cardId) {
+    this.logger?.info("Fetching card...");
+    const response = await this.httpClient.get(
+      `api/v1/cards/${encodeURIComponent(cardId)}`
+    );
+    this.logger?.info("Card fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves active 3DS requests that need to be either approved or declined.
+   */
+  async getActive3dsRequests() {
+    this.logger?.info("Fetching active 3DS requests...");
+    const response = await this.httpClient.get(
+      "api/v1/cards/3ds/requests"
+    );
+    this.logger?.info("Active 3DS requests fetched successfully");
+    return response;
+  }
+  /**
+   * Approves 3DS request allowing the transaction to proceed.
+   */
+  async approve3dsRequest(transactionId) {
+    this.logger?.info("Approving 3DS request...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/3ds/requests/${encodeURIComponent(transactionId)}/approve`
+    );
+    this.logger?.info("3DS request approved successfully");
+    return response;
+  }
+  /**
+   * Declines 3DS request blocking the transaction from proceeding.
+   */
+  async decline3dsRequest(transactionId) {
+    this.logger?.info("Declining 3DS request...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/3ds/requests/${encodeURIComponent(transactionId)}/decline`
+    );
+    this.logger?.info("3DS request declined successfully");
+    return response;
+  }
+  /**
+   * Retrieves list of countries where the card can be delivered for the current corporation.
+   */
+  async getDeliveryCountries() {
+    this.logger?.info("Fetching delivery countries...");
+    const response = await this.httpClient.get("api/v1/cards/delivery/countries");
+    this.logger?.info("Delivery countries fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves list of courier providers that can deliver the card to the specified country.
+   */
+  async getDeliveryMethods(country) {
+    this.logger?.info("Fetching delivery methods...");
+    const response = await this.httpClient.get(
+      `api/v1/cards/delivery/methods/${encodeURIComponent(country)}`
+    );
+    this.logger?.info("Delivery methods fetched successfully");
+    return response;
+  }
+  /**
+   * Issues a plastic card for the specified user and sends it to the provided address.
+   */
+  async issuePlasticCard(request) {
+    this.logger?.info("Issuing plastic card...");
+    const response = await this.httpClient.post("api/v1/cards/plastic", request);
+    this.logger?.info("Plastic card issued successfully");
+    return response;
+  }
+  /**
+   * Issues a virtual card for the specified user.
+   */
+  async issueVirtualCard(request) {
+    this.logger?.info("Issuing virtual card...");
+    const response = await this.httpClient.post("api/v1/cards/virtual", request);
+    this.logger?.info("Virtual card issued successfully");
+    return response;
+  }
+  /**
+   * Activates a card that has been issued to a user and is currently in NotActivated state.
+   */
+  async activateCard(cardId, request) {
+    this.logger?.info("Activating card...");
+    const response = await this.httpClient.put(
+      `api/v1/cards/${encodeURIComponent(cardId)}/activate`,
+      request
+    );
+    this.logger?.info("Card activated successfully");
+    return response;
+  }
+  /**
+   * Blocks selected card making it impossible to use it for any transactions.
+   */
+  async blockCard(cardId) {
+    this.logger?.info("Blocking card...");
+    const response = await this.httpClient.put(
+      `api/v1/cards/${encodeURIComponent(cardId)}/block`
+    );
+    this.logger?.info("Card blocked successfully");
+    return response;
+  }
+  /**
+   * Unblocks selected card allowing it to be used for transactions once again.
+   */
+  async unblockCard(cardId) {
+    this.logger?.info("Unblocking card...");
+    const response = await this.httpClient.put(
+      `api/v1/cards/${encodeURIComponent(cardId)}/unblock`
+    );
+    this.logger?.info("Card unblocked successfully");
+    return response;
+  }
+  /**
+   * Closes the card. This action cannot be undone and the card will be permanently closed.
+   */
+  async closeCard(cardId) {
+    this.logger?.info("Closing card...");
+    const response = await this.httpClient.put(
+      `api/v1/cards/${encodeURIComponent(cardId)}/close`
+    );
+    this.logger?.info("Card closed successfully");
+    return response;
+  }
+  /**
+   * Retrieves card PAN and expiry date using the action confirmation token.
+   */
+  async getCardDetails(cardId, request) {
+    this.logger?.info("Fetching card details...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/${encodeURIComponent(cardId)}/details`,
+      request
+    );
+    this.logger?.info("Card details fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves CVV code for the card using the action confirmation token.
+   */
+  async getCardCvv(cardId, request) {
+    this.logger?.info("Fetching card CVV...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/${encodeURIComponent(cardId)}/cvv`,
+      request
+    );
+    this.logger?.info("Card CVV fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves card Pin code using the action confirmation token.
+   */
+  async getCardPin(cardId, request) {
+    this.logger?.info("Fetching card PIN...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/${encodeURIComponent(cardId)}/pin`,
+      request
+    );
+    this.logger?.info("Card PIN fetched successfully");
+    return response;
+  }
+  /**
+   * Updates maximum amount that can be spent using the card within a day.
+   */
+  async changeCardLimit(cardId, request) {
+    this.logger?.info("Changing card limit...");
+    const response = await this.httpClient.put(
+      `api/v1/cards/${encodeURIComponent(cardId)}/limit`,
+      request
+    );
+    this.logger?.info("Card limit changed successfully");
+    return response;
+  }
+  /**
+   * Updates the display name of the card.
+   */
+  async changeCardName(cardId, request) {
+    this.logger?.info("Changing card name...");
+    const response = await this.httpClient.put(
+      `api/v1/cards/${encodeURIComponent(cardId)}/name`,
+      request
+    );
+    this.logger?.info("Card name changed successfully");
+    return response;
+  }
+  /**
+   * Creates a new card transfer estimation.
+   */
+  async estimateCardTransfer(request) {
+    this.logger?.info("Estimating card transfer...");
+    const response = await this.httpClient.post(
+      "api/v1/cards/transfer/estimate",
+      request
+    );
+    this.logger?.info("Card transfer estimated successfully");
+    return response;
+  }
+  /**
+   * Executes the estimated card transfer request.
+   */
+  async executeCardTransfer(request) {
+    this.logger?.info("Executing card transfer...");
+    const response = await this.httpClient.post(
+      "api/v1/cards/transfer",
+      request
+    );
+    this.logger?.info("Card transfer executed successfully");
+    return response;
+  }
+  /**
+   * Creates a new withdrawal estimation for the card.
+   */
+  async estimateCardWithdrawal(cardId, request) {
+    this.logger?.info("Estimating card withdrawal...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/${encodeURIComponent(cardId)}/withdraw/estimate`,
+      request
+    );
+    this.logger?.info("Card withdrawal estimated successfully");
+    return response;
+  }
+  /**
+   * Executes the estimated withdrawal request for the card.
+   */
+  async executeCardWithdrawal(cardId, request) {
+    this.logger?.info("Executing card withdrawal...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/${encodeURIComponent(cardId)}/withdraw/execute`,
+      request
+    );
+    this.logger?.info("Card withdrawal executed successfully");
+    return response;
+  }
+  /**
+   * Retrieves estimation of fees that should be paid for the card order.
+   */
+  async getOrderFees(type, country) {
+    this.logger?.info("Fetching card order fees...");
+    const response = await this.httpClient.get(
+      `api/v1/cards/${encodeURIComponent(type)}/fees/${encodeURIComponent(country)}`
+    );
+    this.logger?.info("Card order fees fetched successfully");
+    return response;
+  }
+  /**
+   * Creates an invoice for payment of the card order fees.
+   */
+  async createOrderFeesInvoice(type, country, request) {
+    this.logger?.info("Creating card order fees invoice...");
+    const response = await this.httpClient.post(
+      `api/v1/cards/${encodeURIComponent(type)}/fees/${encodeURIComponent(country)}/payment`,
+      request
+    );
+    this.logger?.info("Card order fees invoice created successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/config/config.service.ts
+var ConfigService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves application configuration values for a partner application.
+   */
+  async getConfig() {
+    this.logger?.info("Fetching application configuration...");
+    const response = await this.httpClient.get("api/v1/config", {
+      requireAuth: false
+    });
+    this.logger?.info("Application configuration fetched successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/confirmation/confirmation.service.ts
+var ConfirmationService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Exchanges wallet signature for an action token.
+   */
+  async verifySignature(request) {
+    this.logger?.info("Verifying wallet signature...");
+    const response = await this.httpClient.post(
+      "api/v1/confirmation/signature/verify",
+      request
+    );
+    this.logger?.info("Wallet signature verified successfully");
+    return response;
+  }
+  /**
+   * Sends SMS with OTP code to the user.
+   */
+  async requestSms(request) {
+    this.logger?.info("Requesting SMS confirmation...");
+    const response = await this.httpClient.post(
+      "api/v1/confirmation/sms",
+      request
+    );
+    this.logger?.info("SMS confirmation requested successfully");
+    return response;
+  }
+  /**
+   * Exchanges SMS OTP code for an action token.
+   */
+  async verifySms(request) {
+    this.logger?.info("Verifying SMS code...");
+    const response = await this.httpClient.post("api/v1/confirmation/sms/verify", request);
+    this.logger?.info("SMS code verified successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/recipients/recipients.service.ts
+var RecipientsService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves all recipients with optional pagination and sorting.
+   */
+  async getRecipients(request) {
+    this.logger?.info("Fetching recipients...");
+    const params = {};
+    if (request?.page_number !== void 0) params.page_number = request.page_number;
+    if (request?.page_size !== void 0) params.page_size = request.page_size;
+    if (request?.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/recipients", {
+      params: Object.keys(params).length ? params : void 0
+    });
+    this.logger?.info("Recipients fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves recipients filtered by catalog index (first letter of full name).
+   */
+  async getRecipientsByCatalog(request) {
+    this.logger?.info("Fetching recipients by catalog...");
+    const params = {
+      catalog_index: request.catalog_index
+    };
+    if (request.page_number !== void 0) params.page_number = request.page_number;
+    if (request.page_size !== void 0) params.page_size = request.page_size;
+    if (request.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/recipients/filter/catalog", {
+      params
+    });
+    this.logger?.info("Recipients by catalog fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves recipients filtered by currency.
+   */
+  async getRecipientsByCurrency(request) {
+    this.logger?.info("Fetching recipients by currency...");
+    const params = {
+      currency: request.currency
+    };
+    if (request.page_number !== void 0) params.page_number = request.page_number;
+    if (request.page_size !== void 0) params.page_size = request.page_size;
+    if (request.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/recipients/filter/currency", {
+      params
+    });
+    this.logger?.info("Recipients by currency fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves recipients filtered by name substring.
+   */
+  async getRecipientsByName(request) {
+    this.logger?.info("Fetching recipients by name...");
+    const params = {
+      name: request.name
+    };
+    if (request.page_number !== void 0) params.page_number = request.page_number;
+    if (request.page_size !== void 0) params.page_size = request.page_size;
+    if (request.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/recipients/filter/name", {
+      params
+    });
+    this.logger?.info("Recipients by name fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves recipients filtered by payment details type.
+   */
+  async getRecipientsByType(request) {
+    this.logger?.info("Fetching recipients by type...");
+    const params = {
+      type: request.type
+    };
+    if (request.page_number !== void 0) params.page_number = request.page_number;
+    if (request.page_size !== void 0) params.page_size = request.page_size;
+    if (request.sort) params.sort = request.sort;
+    const response = await this.httpClient.get("api/v1/recipients/filter/type", {
+      params
+    });
+    this.logger?.info("Recipients by type fetched successfully");
+    return response;
+  }
+  /**
+   * Creates a new recipient with provided personal information.
+   */
+  async createRecipient(request) {
+    this.logger?.info("Creating recipient...");
+    const response = await this.httpClient.post("api/v1/recipients", request);
+    this.logger?.info("Recipient created successfully");
+    return response;
+  }
+  /**
+   * Creates a recipient with personal info and payment details in a single call.
+   */
+  async createRecipientV2(request) {
+    this.logger?.info("Creating recipient (v2)...");
+    const response = await this.httpClient.post("api/v2/recipients", request);
+    this.logger?.info("Recipient (v2) created successfully");
+    return response;
+  }
+  /**
+   * Retrieves a single recipient by its ID.
+   */
+  async getRecipientById(recipientId) {
+    this.logger?.info("Fetching recipient by id...");
+    const response = await this.httpClient.get(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}`
+    );
+    this.logger?.info("Recipient fetched successfully");
+    return response;
+  }
+  /**
+   * Updates recipient with provided personal information.
+   */
+  async updateRecipient(recipientId, request) {
+    this.logger?.info("Updating recipient...");
+    const response = await this.httpClient.put(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}`,
+      request
+    );
+    this.logger?.info("Recipient updated successfully");
+    return response;
+  }
+  /**
+   * Deletes selected recipient.
+   */
+  async deleteRecipient(recipientId) {
+    this.logger?.info("Deleting recipient...");
+    const response = await this.httpClient.delete(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}`
+    );
+    this.logger?.info("Recipient deleted successfully");
+    return response;
+  }
+  /**
+   * Creates new payment details for existing recipient.
+   */
+  async createRecipientPaymentDetails(recipientId, request) {
+    this.logger?.info("Creating recipient payment details...");
+    const response = await this.httpClient.post(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}/payment_details`,
+      request
+    );
+    this.logger?.info("Recipient payment details created successfully");
+    return response;
+  }
+  /**
+   * Updates existing payment details for existing recipient.
+   */
+  async updateRecipientPaymentDetails(recipientId, paymentDetailsId, request) {
+    this.logger?.info("Updating recipient payment details...");
+    const response = await this.httpClient.put(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}/payment_details/${encodeURIComponent(
+        paymentDetailsId
+      )}`,
+      request
+    );
+    this.logger?.info("Recipient payment details updated successfully");
+    return response;
+  }
+  /**
+   * Deletes payment details from existing recipient.
+   */
+  async deleteRecipientPaymentDetails(recipientId, paymentDetailsId) {
+    this.logger?.info("Deleting recipient payment details...");
+    const response = await this.httpClient.delete(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}/payment_details/${encodeURIComponent(
+        paymentDetailsId
+      )}`
+    );
+    this.logger?.info("Recipient payment details deleted successfully");
+    return response;
+  }
+  /**
+   * Increments usage index on specified recipient.
+   */
+  async incrementRecipientUsage(recipientId) {
+    this.logger?.info("Incrementing recipient usage...");
+    const response = await this.httpClient.post(
+      `api/v1/recipients/${encodeURIComponent(recipientId)}/usage`
+    );
+    this.logger?.info("Recipient usage incremented successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/rates/rates.service.ts
+var RatesService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves real-time exchange rates for a list of provided tickers.
+   */
+  async getRates(request) {
+    this.logger?.info("Fetching exchange rates...");
+    const query = new URLSearchParams();
+    if (request?.tickers?.length) {
+      request.tickers.forEach((ticker) => query.append("tickers", ticker));
+    }
+    const url = query.toString() ? `api/v1/rates?${query.toString()}` : "api/v1/rates";
+    const response = await this.httpClient.get(url);
+    this.logger?.info("Exchange rates fetched successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/swap/swap.service.ts
+var SwapService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Creates a swap estimation with a deposit address for a Circle FX stablecoin swap.
+   * Send exactly one of source_asset_amount / destination_asset_amount.
+   */
+  async estimate(request) {
+    this.logger?.info("Estimating FX swap...");
+    const response = await this.httpClient.post("api/v1/fx/estimate", request);
+    this.logger?.info("FX swap estimated successfully");
+    return response;
+  }
+  /**
+   * Executes the swap after the source tokens have been sent to the deposit address.
+   */
+  async execute(request) {
+    this.logger?.info("Executing FX swap...");
+    const response = await this.httpClient.post("api/v1/fx", request);
+    this.logger?.info("FX swap executed successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/token/token.service.ts
+var TokenService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Exchanges client credentials for a Wirex Partner access token.
+   */
+  async getToken(request) {
+    this.logger?.info("Requesting OAuth2 token...");
+    const response = await this.httpClient.post("api/v1/token", request, {
+      requireAuth: false
+    });
+    this.logger?.info("OAuth2 token obtained successfully");
+    return response;
+  }
+};
+
+// src/modules/auth/auth.service.ts
+var _AuthService = class _AuthService {
+  constructor(config) {
+    this.state = {
+      accessToken: null,
+      expiresAt: null,
+      userWallet: null
+    };
+    this.httpClient = config.httpClient;
+    this.chainId = config.chainId;
+    this.logger = config.logger;
+  }
+  static initialize(config) {
+    if (!_AuthService.instance) {
+      _AuthService.instance = new _AuthService(config);
+    }
+    return _AuthService.instance;
+  }
+  static getInstance() {
+    if (!_AuthService.instance) {
+      throw new AuthenticationError("AuthService not initialized. Call initialize() first.");
+    }
+    return _AuthService.instance;
+  }
+  static resetInstance() {
+    _AuthService.instance = null;
+  }
+  static buildAuthHeaders(params) {
+    if (params.privy) {
+      return {
+        Authorization: `Bearer ${params.privy.accessToken}`,
+        Identity: `Bearer ${params.privy.identityToken}`
+      };
+    }
+    if (params.authorizationToken) {
+      return {
+        Authorization: `Bearer ${params.authorizationToken}`
+      };
+    }
+    throw new ValidationError("Either privy or authorizationToken must be provided");
+  }
+  async login(params) {
+    this.logger?.info("Logging in user...");
+    const authHeaders = _AuthService.buildAuthHeaders(params);
+    if (params.userWallet) {
+      authHeaders["X-User-Wallet"] = params.userWallet;
+      this.state.userWallet = params.userWallet;
+    }
+    authHeaders["X-Chain-Id"] = String(this.chainId);
+    try {
+      const response = await this.httpClient.post(
+        "api/v1/user/authorize",
+        {},
+        {
+          headers: authHeaders,
+          requireAuth: false
+        }
+      );
+      this.setAuthState(response);
+      this.logger?.info("User logged in successfully");
+      return response;
+    } catch (error) {
+      this.logger?.error("Login failed:", error?.message);
+      throw error;
+    }
+  }
+  async loginCompany(params) {
+    this.logger?.info("Logging in company...", { companyAddress: params.companyAddress });
+    const authHeaders = _AuthService.buildAuthHeaders(params);
+    const body = params.companyAddress ? { corporation_address: params.companyAddress } : void 0;
+    const response = await this.httpClient.post(
+      "api/v1/corporations/login",
+      body,
+      {
+        headers: authHeaders,
+        requireAuth: false
+      }
+    );
+    this.setAuthState(response);
+    this.logger?.info("Company logged in successfully");
+    return response;
+  }
+  async registerUser(params) {
+    this.logger?.info("Registering user...");
+    const authHeaders = _AuthService.buildAuthHeaders(params);
+    authHeaders["X-Chain-Id"] = String(this.chainId);
+    if (params.privy) {
+      if (params.userWallet) {
+        authHeaders["X-User-Wallet"] = params.userWallet;
+      }
+      const response = await this.httpClient.post(
+        "api/v1/user/retail",
+        { country: params.country },
+        {
+          headers: authHeaders,
+          requireAuth: false
+        }
+      );
+      this.logger?.info("User registered successfully", { userId: response.id });
+      return response;
+    }
+    try {
+      const body = { wallet_address: params.userWallet };
+      if (params.initialData) {
+        body.initial_data = params.initialData;
+      }
+      const response = await this.httpClient.post(
+        "api/v2/user",
+        body,
+        {
+          headers: authHeaders,
+          requireAuth: false
+        }
+      );
+      this.logger?.info("User registered successfully", { userId: response.id });
+      return response;
+    } catch (error) {
+      this.logger?.error("User registration failed:", error?.message);
+      throw error;
+    }
+  }
+  async registerCompany(params) {
+    this.logger?.info("Registering company...", { companyName: params.companyName });
+    const authHeaders = _AuthService.buildAuthHeaders(params);
+    await this.httpClient.post(
+      "api/v1/corporations/register",
+      {
+        corporation_address: params.companyAddress,
+        corporation_name: params.companyName,
+        corporation_registration_country: params.registrationCountry,
+        corporation_registration_number: params.registrationNumber
+      },
+      {
+        headers: authHeaders,
+        requireAuth: false
+      }
+    );
+    this.logger?.info("Company registered successfully");
+  }
+  setAuthState(response, userWallet) {
+    this.state.accessToken = response.access_token;
+    this.state.expiresAt = response.expires_at;
+    if (userWallet) {
+      this.state.userWallet = userWallet;
+    }
+  }
+  setUserWallet(wallet) {
+    this.state.userWallet = wallet;
+  }
+  getAccessToken() {
+    if (!this.state.accessToken) {
+      return null;
+    }
+    if (this.isTokenExpired()) {
+      this.logger?.warn("Access token has expired");
+      this.clearAuth();
+      return null;
+    }
+    return this.state.accessToken;
+  }
+  isAuthenticated() {
+    return this.getAccessToken() !== null;
+  }
+  getUserWallet() {
+    return this.state.userWallet;
+  }
+  isTokenExpired() {
+    if (!this.state.expiresAt) {
+      return true;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    return this.state.expiresAt < now;
+  }
+  clearAuth() {
+    this.state = {
+      accessToken: null,
+      expiresAt: null,
+      userWallet: null
+    };
+    this.logger?.info("Auth state cleared");
+  }
+  ensureAuthenticated() {
+    if (!this.isAuthenticated()) {
+      throw new AuthenticationError("User is not authenticated. Please login first.");
+    }
+  }
+  getAuthHeaders() {
+    const headers = {};
+    const token = this.getAccessToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (this.state.userWallet) {
+      headers["X-User-Wallet"] = this.state.userWallet;
+    }
+    return headers;
+  }
+};
+_AuthService.instance = null;
+var AuthService = _AuthService;
+
+// src/modules/api/baas/user/user.service.ts
+var UserService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Initiates a phone number update for the authenticated user.
+   */
+  async updatePhoneNumber(request) {
+    this.logger?.info("Updating phone number...");
+    await this.httpClient.put("api/v1/user/phone-number", request);
+    this.logger?.info("Phone number updated successfully");
+  }
+  /**
+   * Confirms and completes the phone number update with SMS verification code.
+   */
+  async confirmPhoneNumber(request) {
+    this.logger?.info("Confirming phone number...");
+    await this.httpClient.put("api/v1/user/phone-number/confirm", request);
+    this.logger?.info("Phone number confirmed successfully");
+  }
+  /**
+   * Uploads a KYC verification document using multipart/form-data.
+   */
+  async uploadDocument(formData) {
+    this.logger?.info("Uploading document...");
+    await this.httpClient.post("api/v1/user/documents", formData, {
+      headers: { "Content-Type": void 0 }
+    });
+    this.logger?.info("Document uploaded successfully");
+  }
+  /**
+   * Fetches the complete profile for the authenticated user (V1).
+   */
+  async getUser() {
+    this.logger?.info("Fetching user details...");
+    const response = await this.httpClient.get("api/v1/user");
+    this.logger?.info("User details fetched successfully");
+    return response;
+  }
+  /**
+   * Associates a Freshdesk customer ID with the user's account.
+   */
+  async updateFreshdeskId(request) {
+    this.logger?.info("Updating Freshdesk ID...");
+    await this.httpClient.put("api/v1/user/freshdesk-id", request);
+    this.logger?.info("Freshdesk ID updated successfully");
+  }
+  /**
+   * Generates a temporary token for secure user data sharing with SumSub.
+   */
+  async getSharingToken(request) {
+    this.logger?.info("Generating sharing token...");
+    const response = await this.httpClient.get(
+      `api/v1/user/sharing-token?sumsub_client_id=${encodeURIComponent(request.sumsub_client_id)}`
+    );
+    this.logger?.info("Sharing token generated successfully");
+    return response;
+  }
+  /**
+   * Generates an access token for SumSub KYC identity verification.
+   */
+  async getVerificationToken() {
+    this.logger?.info("Getting verification token...");
+    const response = await this.httpClient.post(
+      "api/v1/user/verification-token",
+      {}
+    );
+    this.logger?.info("Verification token retrieved successfully");
+    return response;
+  }
+  async createUser(request) {
+    this.logger?.info("Creating user...");
+    const response = await this.httpClient.post("api/v1/user", request);
+    this.logger?.info("User created successfully");
+    return response;
+  }
+  /**
+   * Sets a KYC sharing token to ingest user data from SumSub.
+   */
+  async setSharingToken(request) {
+    this.logger?.info("Setting sharing token...");
+    const response = await this.httpClient.post(
+      "api/v1/user/sharing-token",
+      request
+    );
+    this.logger?.info("Sharing token set successfully");
+    return response;
+  }
+  /**
+   * Creates a new retail user in the Wirex system using client-side Privy SDK authorization.
+   */
+  async createRetailUser(request) {
+    this.logger?.info("Creating retail user...");
+    const response = await this.httpClient.post(
+      "api/v1/user/retail",
+      request
+    );
+    this.logger?.info("Retail user created successfully");
+    return response;
+  }
+  /**
+   * Validates a retail user in the Wirex system using client-side Privy SDK authorization.
+   */
+  async validateRetailUser() {
+    this.logger?.info("Validating retail user...");
+    const response = await this.httpClient.post(
+      "api/v1/user/retail/validate",
+      {}
+    );
+    this.logger?.info("Retail user validated successfully");
+    return response;
+  }
+  /**
+   * Generates a verification link for the user to complete KYC via SumSub.
+   */
+  async getVerificationLink() {
+    this.logger?.info("Getting verification link...");
+    const response = await this.httpClient.post(
+      "api/v1/user/verification-link",
+      {}
+    );
+    this.logger?.info("Verification link retrieved successfully");
+    return response;
+  }
+  /**
+   * Retrieves an access token for a specific user to interact with all other APIs on their behalf.
+   */
+  async authorizeUser(params) {
+    this.logger?.info("Authorizing user...");
+    const headers = AuthService.buildAuthHeaders(params);
+    const response = await this.httpClient.post(
+      "api/v1/user/authorize",
+      {},
+      {
+        headers,
+        requireAuth: false
+      }
+    );
+    this.authService.setAuthState(response);
+    this.logger?.info("User authorized successfully");
+    return response;
+  }
+  /**
+   * Retrieves extended user account information (V2).
+   */
+  async getUserV2() {
+    this.logger?.info("Fetching user details (v2)...");
+    const response = await this.httpClient.get("api/v2/user");
+    this.logger?.info("User details (v2) fetched successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/wallet/wallet.service.ts
+var WalletService = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.authService = config.authService;
+    this.logger = config.logger;
+  }
+  /**
+   * Retrieves a wallet and its balances. Optionally filtered by wallet address.
+   */
+  async getWallet(request) {
+    this.logger?.info("Fetching wallet...");
+    const params = {};
+    if (request?.wallet_address !== void 0) params.wallet_address = request.wallet_address;
+    const response = await this.httpClient.get("api/v1/wallet", {
+      params: Object.keys(params).length ? params : void 0
+    });
+    this.logger?.info("Wallet fetched successfully");
+    return response;
+  }
+  /**
+   * Retrieves user wallets and their balances.
+   */
+  async getWallets() {
+    this.logger?.info("Fetching wallets...");
+    const response = await this.httpClient.get("api/v1/wallets");
+    this.logger?.info("Wallets fetched successfully");
+    return response;
+  }
+  /**
+   * Creates a global wallet for the user account.
+   */
+  async createGlobalWallet(request) {
+    this.logger?.info("Creating global wallet...");
+    const response = await this.httpClient.post("api/v1/wallets/global", request);
+    this.logger?.info("Global wallet created successfully");
+    return response;
+  }
+};
+
+// src/modules/api/baas/baas.module.ts
+var BaasModule = class {
+  constructor(context) {
+    this.name = "baas";
+    this._initialized = false;
+    this.context = context;
+    this.logger = context.logger;
+  }
+  async initialize() {
+    if (this._initialized) {
+      this.logger.warn("BaasModule already initialized");
+      return;
+    }
+    this.logger.info("Initializing BaasModule...");
+    const httpClient = this.context.httpClient;
+    const authService = AuthService.getInstance();
+    this._userService = new UserService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._activityService = new ActivityService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._bankService = new BankService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._cardsService = new CardsService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._configService = new ConfigService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._confirmationService = new ConfirmationService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._recipientsService = new RecipientsService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._ratesService = new RatesService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._swapService = new SwapService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._tokenService = new TokenService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._walletService = new WalletService({
+      httpClient,
+      authService,
+      logger: this.logger
+    });
+    this._initialized = true;
+    this.logger.info("BaasModule initialized successfully");
+  }
+  isInitialized() {
+    return this._initialized;
+  }
+  get user() {
+    if (!this._userService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._userService;
+  }
+  get activity() {
+    if (!this._activityService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._activityService;
+  }
+  get bank() {
+    if (!this._bankService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._bankService;
+  }
+  get cards() {
+    if (!this._cardsService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._cardsService;
+  }
+  get config() {
+    if (!this._configService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._configService;
+  }
+  get confirmation() {
+    if (!this._confirmationService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._confirmationService;
+  }
+  get recipients() {
+    if (!this._recipientsService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._recipientsService;
+  }
+  get rates() {
+    if (!this._ratesService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._ratesService;
+  }
+  get swap() {
+    if (!this._swapService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._swapService;
+  }
+  get token() {
+    if (!this._tokenService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._tokenService;
+  }
+  get wallet() {
+    if (!this._walletService) {
+      throw new Error("BaasModule not initialized. Call initialize() first.");
+    }
+    return this._walletService;
+  }
+};
+
+// src/modules/api/internal/endpoints/withdrawal.api.ts
+var WithdrawalApi = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async getWithdrawalRequests() {
+    const response = await this.httpClient.get(
+      "api/v1/withdrawal/requests"
+    );
+    return response.data ?? [];
+  }
+};
+
+// src/modules/api/api.module.ts
+var ApiModule = class {
+  constructor(context) {
+    this.name = "api";
+    this._initialized = false;
+    this.context = context;
+    this.logger = context.logger;
+    this.httpClient = context.httpClient;
+  }
+  async initialize() {
+    if (this._initialized) {
+      this.logger.warn("API module already initialized");
+      return;
+    }
+    this.logger.info("Initializing API module...");
+    this._withdrawal = new WithdrawalApi(this.httpClient);
+    this._baas = new BaasModule(this.context);
+    await this._baas.initialize();
+    this._initialized = true;
+    this.logger.info("API module initialized successfully");
+  }
+  isInitialized() {
+    return this._initialized;
+  }
+  get baas() {
+    if (!this._baas) {
+      throw new Error("API module not initialized");
+    }
+    return this._baas;
+  }
+  get withdrawal() {
+    if (!this._withdrawal) {
+      throw new Error("API module not initialized");
+    }
+    return this._withdrawal;
+  }
+};
+
+export { ActivityService, ApiModule, AuthService, BaasModule, BankService, CardsService, ConfigService, ConfirmationService, RatesService, RecipientsService, SwapService, TokenService, UserService, WalletService, WithdrawalApi };
+//# sourceMappingURL=chunk-D2YHFKQI.js.map
+//# sourceMappingURL=chunk-D2YHFKQI.js.map