@cuenca-mx/cuenca-js 0.0.1-dev.4 → 0.0.1-dev.5

package/build/index.mjs

@@ -0,0 +1,1475 @@
+import axios from 'axios';
+import { CuencaResponseException, CuencaException, NoResultFound, MultipleResultsFound, InvalidPassword } from './errors/index.mjs';
+export { CuencaException, CuencaResponseException, InvalidPassword, MalformedJwtToken, MultipleResultsFound, NoResultFound, ValidationError } from './errors/index.mjs';
+import { Jwt } from './jwt/index.mjs';
+export { Jwt } from './jwt/index.mjs';
+import { P as Phase, F as FileFormat, E as EntryType, T as TransactionStatus, C as CardIssuer, a as CardStatus, b as CardType, c as CardFundingType, d as CardErrorType, e as CardTransactionType, f as CommissionType, D as DepositNetwork, S as SavingCategory, g as ServiceProviderCategory, h as TransferNetwork, W as WalletTransactionType, A as AccountQuery, i as ApiKeyQuery, B as BalanceEntryQuery, j as BillPaymentQuery, k as CardsQuery, l as CardTransactionQuery, Q as QueryParams, m as DepositQuery, n as WalletQuery, o as StatementQuery, p as TransferQuery, q as WalletTransactionQuery } from './queries-f146b91b.js';
+export { A as AccountQuery, i as ApiKeyQuery, B as BalanceEntryQuery, j as BillPaymentQuery, d as CardErrorType, c as CardFundingType, C as CardIssuer, a as CardStatus, l as CardTransactionQuery, e as CardTransactionType, b as CardType, k as CardsQuery, f as CommissionType, D as DepositNetwork, m as DepositQuery, E as EntryType, F as FileFormat, s as PageSize, P as Phase, Q as QueryParams, S as SavingCategory, g as ServiceProviderCategory, o as StatementQuery, r as TrackDataMethod, T as TransactionStatus, h as TransferNetwork, p as TransferQuery, n as WalletQuery, q as WalletTransactionQuery, W as WalletTransactionType } from './queries-f146b91b.js';
+import { d as dateToUTC, e as enumValueFromString } from './data-7d3d5fcc.js';
+import { A as ApiKeyUpdateRequest, a as ArpcRequest, C as CardActivationRequest, b as CardRequest, c as CardUpdateRequest, d as CardValidationRequest, S as SavingRequest, T as TransferRequest, U as UserCredentialRequest, e as UserCredentialUpdateRequest, f as UserLoginRequest, W as WalletTransactionRequest } from './walletTransactionRequest-bbfb87bd.js';
+
+class Client {
+  constructor({ apiKey, apiSecret, phase = Phase.Sandbox } = {}) {
+    this.phase = phase;
+    this.basicAuth = { apiKey, apiSecret };
+    this.jwtToken = null;
+    this._session = axios.create();
+  }
+
+  get session() {
+    return this._session;
+  }
+
+  get origin() {
+    return `https://${this.phase.value}.cuenca.com`;
+  }
+
+  get authHeader() {
+    const { apiKey, apiSecret } = this.basicAuth;
+    if (!apiKey || !apiSecret) return '';
+    return `Basic ${Buffer.from(
+      Buffer.from(`${apiKey}:${apiSecret}`).toString('utf-8'),
+    ).toString('base64')}`;
+  }
+
+  addHeadersToRequest(obj) {
+    const interceptorId = this._session.interceptors.request.use((config) => {
+      const currentConfig = config;
+      const {
+        headers: { common },
+      } = currentConfig;
+      Object.keys(obj).forEach((k) => (common[k] = obj[k]));
+      return currentConfig;
+    });
+    return {
+      interceptorId,
+      eject: () => this._session.interceptors.request.eject(interceptorId),
+    };
+  }
+
+  deleteRequestHeader(header) {
+    const interceptorId = this._session.interceptors.request.use((config) => {
+      const currentConfig = config;
+      const {
+        headers: { common },
+      } = currentConfig;
+      delete common[header];
+      return currentConfig;
+    });
+    return {
+      interceptorId,
+      eject: () => this._session.interceptors.request.eject(interceptorId),
+    };
+  }
+
+  addConfigToRequest(obj) {
+    const interceptorId = this._session.interceptors.request.use((config) => {
+      const currentConfig = config;
+      Object.keys(obj).forEach((k) => (currentConfig[k] = obj[k]));
+      return currentConfig;
+    });
+    return {
+      interceptorId,
+      eject: () => this._session.interceptors.request.eject(interceptorId),
+    };
+  }
+
+  async configure({ apiKey, apiSecret, loginToken, phase, useJwt = false }) {
+    this.basicAuth = {
+      apiKey: apiKey || this.basicAuth.apiKey,
+      apiSecret: apiSecret || this.basicAuth.apiSecret,
+    };
+
+    if (phase) this.phase = phase;
+
+    if (useJwt) this.jwtToken = await Jwt.create(this);
+
+    if (loginToken) {
+      this.addHeadersToRequest({ 'X-Cuenca-LoginToken': loginToken });
+    }
+  }
+
+  async get({ endpoint, format, params }) {
+    return this.request({ endpoint, format, params });
+  }
+
+  async post({ endpoint, data }) {
+    return this.request({ method: 'POST', endpoint, data });
+  }
+
+  async patch({ endpoint, data }) {
+    return this.request({ method: 'PATCH', endpoint, data });
+  }
+
+  async delete({ endpoint, data }) {
+    return this.request({ method: 'DELETE', endpoint, data });
+  }
+
+  async request({
+    endpoint,
+    data = null,
+    format = FileFormat.Json,
+    method = 'GET',
+    params = null,
+  }) {
+    const headers = {
+      Authorization: this.authHeader,
+      'X-User-Agent': `cuenca-js/0.0.1`, // TODO: Change for client version
+      'Content-Type': 'application/json',
+      Accept: `application/${format.value}`,
+    };
+
+    if (this.jwtToken) {
+      if (this.jwtToken.isExpired) {
+        this.jwtToken = await Jwt.create(this);
+      }
+      headers['X-Cuenca-Token'] = this.jwtToken.token;
+    }
+
+    const headersInterceptor = this.addHeadersToRequest(headers);
+
+    const modifiedData = data;
+    if (modifiedData) {
+      Object.keys(modifiedData).forEach((k) => {
+        if (modifiedData[k] instanceof Date) {
+          modifiedData[k] = modifiedData[k].toISOString();
+        }
+      });
+    }
+
+    const configInterceptor = this.addConfigToRequest({
+      method,
+      params,
+      data: modifiedData,
+      url: endpoint,
+    });
+
+    let response;
+    try {
+      response = await this._session.request({ baseURL: this.origin });
+    } catch (error) {
+      if (error.response) {
+        throw new CuencaResponseException(
+          error.response.data,
+          error.response.status,
+        );
+      } else if (error.request) {
+        throw new CuencaException(
+          `No response received: ${error.errno}: ${error.code}`,
+        );
+      } else {
+        throw new CuencaException(error.message);
+      }
+    } finally {
+      headersInterceptor.eject();
+      configInterceptor.eject();
+    }
+
+    return response.data;
+  }
+}
+
+class Account {
+  constructor({ accountNumber, createdAt, id, institutionName, name, userId }) {
+    this.accountNumber = accountNumber;
+    this.createdAt = dateToUTC(createdAt);
+    this.id = id;
+    this.institutionName = institutionName;
+    this.name = name;
+    this.userId = userId;
+  }
+
+  static fromObject = ({ id, name, ...obj }) =>
+    new Account({
+      id,
+      name,
+      accountNumber: obj.account_number,
+      createdAt: obj.created_at,
+      institutionName: obj.institution_name,
+      userId: obj.user_id,
+    });
+}
+
+class ApiKey {
+  constructor({ createdAt, deactivatedAt, id, secret, userId, updatedAt }) {
+    this.createdAt = dateToUTC(createdAt);
+    this.deactivatedAt = dateToUTC(deactivatedAt);
+    this.id = id;
+    this.secret = secret;
+    this.userId = userId;
+    this.updatedAt = dateToUTC(updatedAt);
+  }
+
+  static fromObject = ({ id, secret, ...obj }) =>
+    new ApiKey({
+      id,
+      secret,
+      createdAt: obj.created_at,
+      deactivatedAt: obj.deactivated_at,
+      userId: obj.user_id,
+      updatedAt: obj.updated_at,
+    });
+
+  get isActive() {
+    const todayUTC = dateToUTC(Date.now());
+    return (
+      !this.deactivatedAt || this.deactivatedAt.getTime() > todayUTC.getTime()
+    );
+  }
+}
+
+class Arpc {
+  constructor({ arpc, createdAt, cardUri, isValidArqc }) {
+    this.arpc = arpc;
+    this.createdAt = dateToUTC(createdAt);
+    this.cardUri = cardUri;
+    this.isValidArqc = isValidArqc;
+  }
+
+  static fromObject = ({ arpc, ...obj }) =>
+    new Arpc({
+      arpc,
+      createdAt: obj.created_at,
+      cardUri: obj.card_uri,
+      isValidArqc: obj.is_valid_arqc,
+    });
+}
+
+class BalanceEntry {
+  constructor({
+    amount,
+    createdAt,
+    descriptor,
+    entryType,
+    fundingInstrumentUri,
+    id,
+    name,
+    relatedTransactionUri,
+    rollingBalance,
+  }) {
+    this.amount = amount;
+    this.createdAt = dateToUTC(createdAt);
+    this.descriptor = descriptor;
+    this.entryType = enumValueFromString(EntryType, entryType);
+    this.fundingInstrumentUri = fundingInstrumentUri;
+    this.id = id;
+    this.name = name;
+    this.relatedTransactionUri = relatedTransactionUri;
+    this.rollingBalance = rollingBalance;
+  }
+
+  static fromObject = ({ amount, descriptor, id, name, type, ...obj }) =>
+    new BalanceEntry({
+      amount,
+      descriptor,
+      name,
+      id,
+      createdAt: obj.created_at,
+      entryType: type,
+      fundingInstrumentUri: obj.funding_instrument_uri,
+      relatedTransactionUri: obj.related_transaction_uri,
+      rollingBalance: obj.rolling_balance,
+    });
+}
+
+class Transaction {
+  constructor({ amount, createdAt, descriptor, status, userId }) {
+    this.amount = amount;
+    this.createdAt = dateToUTC(createdAt);
+    this.descriptor = descriptor;
+    this.status = enumValueFromString(TransactionStatus, status);
+    this.userId = userId;
+  }
+}
+
+class BillPayment extends Transaction {
+  constructor({
+    amount,
+    accountNumber,
+    createdAt,
+    descriptor,
+    id,
+    providerUri,
+    status,
+    userId,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.accountNumber = accountNumber;
+    this.id = id;
+    this.providerUri = providerUri;
+  }
+
+  static fromObject = ({ amount, descriptor, id, status, ...obj }) =>
+    new BillPayment({
+      amount,
+      descriptor,
+      id,
+      status,
+      accountNumber: obj.account_number,
+      createdAt: obj.created_at,
+      providerUri: obj.provider_uri,
+      userId: obj.user_id,
+    });
+}
+
+class Card {
+  constructor({
+    createdAt,
+    cvv2,
+    expMonth,
+    expYear,
+    fundingType,
+    id,
+    issuer,
+    number,
+    pin,
+    status,
+    type,
+    updatedAt,
+    userId,
+  }) {
+    this.createdAt = dateToUTC(createdAt);
+    this.cvv2 = cvv2;
+    this.expMonth = expMonth;
+    this.expYear = expYear;
+    this.fundingType = enumValueFromString(CardFundingType, fundingType);
+    this.id = id;
+    this.issuer = enumValueFromString(CardIssuer, issuer);
+    this.number = number;
+    this.pin = pin;
+    this.status = enumValueFromString(CardStatus, status);
+    this.type = enumValueFromString(CardType, type);
+    this.updatedAt = dateToUTC(updatedAt);
+    this.userId = userId;
+  }
+
+  static fromObject = ({
+    cvv2,
+    id,
+    issuer,
+    number,
+    pin,
+    status,
+    type,
+    ...obj
+  }) =>
+    new Card({
+      cvv2,
+      id,
+      issuer,
+      number,
+      pin,
+      status,
+      type,
+      createdAt: obj.created_at,
+      expMonth: obj.exp_month,
+      expYear: obj.exp_year,
+      fundingType: obj.funding_type,
+      updatedAt: obj.updated_at,
+      userId: obj.user_id,
+    });
+}
+
+class CardActivation {
+  constructor({ cardUri, createdAt, id, ipAddress, success, userId }) {
+    this.cardUri = cardUri;
+    this.createdAt = dateToUTC(createdAt);
+    this.id = id;
+    this.ipAddress = ipAddress;
+    this.success = success;
+    this.userId = userId;
+  }
+
+  static fromObject = ({ id, success, ...obj }) =>
+    new CardActivation({
+      id,
+      success,
+      cardUri: obj.card_uri,
+      createdAt: obj.created_at,
+      ipAddress: obj.ip_address,
+      userId: obj.user_id,
+    });
+}
+
+class CardTransaction extends Transaction {
+  constructor({
+    amount,
+    cardErrorType,
+    cardLastFour,
+    cardType,
+    cardUri,
+    createdAt,
+    descriptor,
+    metadata,
+    network,
+    relatedCardTransactionsUris,
+    status,
+    type,
+    userId,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.cardErrorType = enumValueFromString(CardErrorType, cardErrorType);
+    this.cardLastFour = cardLastFour;
+    this.cardType = enumValueFromString(CardType, cardType);
+    this.cardUri = cardUri;
+    this.metadata = metadata;
+    this.network = network;
+    this.relatedCardTransactionsUris = relatedCardTransactionsUris;
+    this.type = enumValueFromString(CardTransactionType, type);
+  }
+
+  static fromObject = ({
+    amount,
+    descriptor,
+    metadata,
+    network,
+    status,
+    type,
+    ...obj
+  }) =>
+    new CardTransaction({
+      amount,
+      descriptor,
+      metadata,
+      network,
+      status,
+      type,
+      cardErrorType: obj.error_type,
+      cardLastFour: obj.card_last4,
+      cardType: obj.card_type,
+      cardUri: obj.card_uri,
+      createdAt: obj.created_at,
+      relatedCardTransactionsUris: obj.related_card_transaction,
+      userId: obj.user_id,
+    });
+}
+
+class CardValidation {
+  constructor({
+    cardStatus,
+    cardType,
+    cardUri,
+    createdAt,
+    isExpired,
+    isPinAttemptsExceeded,
+    isValidCvv,
+    isValidCvv2,
+    isValidExpDate,
+    isValidIcvv,
+    isValidPinBlock,
+    userId,
+  }) {
+    this.cardStatus = enumValueFromString(CardStatus, cardStatus);
+    this.cardType = enumValueFromString(CardType, cardType);
+    this.cardUri = cardUri;
+    this.createdAt = dateToUTC(createdAt);
+    this.isExpired = isExpired;
+    this.isPinAttemptsExceeded = isPinAttemptsExceeded;
+    this.isValidCvv = isValidCvv;
+    this.isValidCvv2 = isValidCvv2;
+    this.isValidExpDate = isValidExpDate;
+    this.isValidIcvv = isValidIcvv;
+    this.isValidPinBlock = isValidPinBlock;
+    this.userId = userId;
+  }
+
+  static fromObject = ({ ...obj }) =>
+    new CardValidation({
+      cardStatus: obj.card_status,
+      cardType: obj.card_type,
+      cardUri: obj.card_uri,
+      createdAt: obj.created_at,
+      isExpired: obj.is_expired,
+      isPinAttemptsExceeded: obj.is_pin_attempts_exceeded,
+      isValidCvv: obj.is_valid_cvv,
+      isValidCvv2: obj.is_valid_cvv2,
+      isValidExpDate: obj.is_valid_exp_date,
+      isValidIcvv: obj.is_valid_icvv,
+      isValidPinBlock: obj.is_valid_pin_block,
+      userId: obj.user_id,
+    });
+
+  get isActive() {
+    return this.cardStatus === CardStatus.Active;
+  }
+}
+
+class Commission extends Transaction {
+  constructor({
+    amount,
+    createdAt,
+    descriptor,
+    relatedTransactionUri,
+    status,
+    type,
+    userId,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.relatedTransactionUri = relatedTransactionUri;
+    this.type = enumValueFromString(CommissionType, type);
+  }
+
+  static fromObject = ({ amount, descriptor, status, type, ...obj }) =>
+    new Commission({
+      amount,
+      descriptor,
+      status,
+      type,
+      createdAt: obj.created_at,
+      relatedTransactionUri: obj.related_transaction_uri,
+      userId: obj.user_id,
+    });
+}
+
+class Deposit extends Transaction {
+  constructor({
+    amount,
+    createdAt,
+    descriptor,
+    id,
+    network,
+    status,
+    sourceUri,
+    trackingKey,
+    userId,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.id = id;
+    this.network = enumValueFromString(DepositNetwork, network);
+    this.sourceUri = sourceUri;
+    this.trackingKey = trackingKey;
+  }
+
+  static fromObject = ({ amount, descriptor, id, network, status, ...obj }) =>
+    new Deposit({
+      amount,
+      descriptor,
+      id,
+      network,
+      status,
+      createdAt: obj.created_at,
+      sourceUri: obj.source_uri,
+      trackingKey: obj.tracking_key,
+      userId: obj.user_id,
+    });
+}
+
+class LoginToken {
+  constructor({ id }) {
+    this.id = id;
+  }
+
+  static fromObject = ({ id }) => new LoginToken({ id });
+}
+
+class Wallet {
+  constructor({ balance, createdAt, deactivatedAt, id, userId, updatedAt }) {
+    this.balance = balance;
+    this.createdAt = dateToUTC(createdAt);
+    this.deactivatedAt = dateToUTC(deactivatedAt);
+    this.id = id;
+    this.userId = userId;
+    this.updatedAt = dateToUTC(updatedAt);
+  }
+}
+
+class Saving extends Wallet {
+  constructor({
+    balance,
+    category,
+    createdAt,
+    deactivatedAt,
+    goalAmount,
+    goalDate,
+    id,
+    name,
+    userId,
+    updatedAt,
+  }) {
+    super({ balance, createdAt, deactivatedAt, id, userId, updatedAt });
+    this.category = enumValueFromString(SavingCategory, category);
+    this.goalAmount = goalAmount;
+    this.goalDate = dateToUTC(goalDate);
+    this.name = name;
+  }
+
+  static fromObject = ({ balance, category, id, name, ...obj }) =>
+    new Saving({
+      balance,
+      category,
+      id,
+      name,
+      createdAt: obj.created_at,
+      deactivatedAt: obj.deactivated_at,
+      goalAmount: obj.goal_amount,
+      goalDate: obj.goal_date,
+      userId: obj.user_id,
+      updatedAt: obj.updated_at,
+    });
+}
+
+const categoriesFromString = (categoriesList) => {
+  if (categoriesList == null) return [];
+  return categoriesList.map((category) =>
+    enumValueFromString(ServiceProviderCategory, category),
+  );
+};
+
+class ServiceProvider {
+  constructor({ categories, id, name, providerKey }) {
+    this.categories = categoriesFromString(categories);
+    this.id = id;
+    this.name = name;
+    this.providerKey = providerKey;
+  }
+
+  static fromObject = ({ categories, id, name, ...obj }) =>
+    new ServiceProvider({
+      categories,
+      id,
+      name,
+      providerKey: obj.provider_key,
+    });
+}
+
+class Statement {
+  constructor({ createdAt, id, month, year }) {
+    this.createdAt = dateToUTC(createdAt);
+    this.id = id;
+    this.month = month;
+    this.year = year;
+  }
+
+  static fromObject = ({ id, month, year, ...obj }) =>
+    new Statement({
+      id,
+      month,
+      year,
+      createdAt: obj.created_at,
+    });
+}
+
+class Transfer extends Transaction {
+  constructor({
+    accountNumber,
+    amount,
+    createdAt,
+    descriptor,
+    destinationUri,
+    id,
+    idempotencyKey,
+    network,
+    recipientName,
+    status,
+    trackingKey,
+    updatedAt,
+    userId,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.accountNumber = accountNumber;
+    this.destinationUri = destinationUri;
+    this.id = id;
+    this.idempotencyKey = idempotencyKey;
+    this.network = enumValueFromString(TransferNetwork, network);
+    this.recipientName = recipientName;
+    this.trackingKey = trackingKey;
+    this.updatedAt = dateToUTC(updatedAt);
+  }
+
+  static fromObject = ({ amount, descriptor, id, network, status, ...obj }) =>
+    new Transfer({
+      amount,
+      descriptor,
+      id,
+      network,
+      status,
+      accountNumber: obj.account_number,
+      createdAt: obj.created_at,
+      destinationUri: obj.destination_uri,
+      idempotencyKey: obj.idempotency_key,
+      recipientName: obj.recipient_name,
+      trackingKey: obj.tracking_key,
+      updatedAt: obj.updated_at,
+      userId: obj.user_id,
+    });
+}
+
+class UserCredential {
+  constructor({ createdAt, id, isActive, updatedAt }) {
+    this.createdAt = dateToUTC(createdAt);
+    this.id = id;
+    this.isActive = isActive;
+    this.updatedAt = dateToUTC(updatedAt);
+  }
+
+  static fromObject = ({ id, ...obj }) =>
+    new UserCredential({
+      id,
+      createdAt: obj.created_at,
+      isActive: obj.is_active,
+      updatedAt: obj.updated_at,
+    });
+}
+
+class UserLogin {
+  constructor({ id, lastLoginAt, success }) {
+    this.id = id;
+    this.lastLoginAt = dateToUTC(lastLoginAt);
+    this.success = success;
+  }
+
+  static fromObject = ({ id, success, ...obj }) =>
+    new UserLogin({
+      id,
+      success,
+      lastLoginAt: obj.last_login_at,
+    });
+}
+
+class WalletTransaction extends Transaction {
+  constructor({
+    amount,
+    createdAt,
+    descriptor,
+    id,
+    status,
+    transactionType,
+    userId,
+    walletUri,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.id = id;
+    this.transactionType = enumValueFromString(
+      WalletTransactionType,
+      transactionType,
+    );
+    this.walletUri = walletUri;
+  }
+
+  static fromObject = ({ amount, descriptor, id, status, ...obj }) =>
+    new WalletTransaction({
+      amount,
+      descriptor,
+      id,
+      status,
+      createdAt: obj.created_at,
+      transactionType: obj.transaction_type,
+      userId: obj.user_id,
+      walletUri: obj.wallet_uri,
+    });
+}
+
+class WhatsAppTransfer extends Transaction {
+  constructor({
+    amount,
+    claimUrl,
+    createdAt,
+    descriptor,
+    destinationUri,
+    expiresAt,
+    id,
+    network,
+    phoneNumber,
+    recipientName,
+    status,
+    trackingKey,
+    updatedAt,
+    userId,
+  }) {
+    super({ amount, createdAt, descriptor, status, userId });
+    this.claimUrl = claimUrl;
+    this.destinationUri = destinationUri;
+    this.id = id;
+    this.expiresAt = dateToUTC(expiresAt);
+    this.network = enumValueFromString(TransferNetwork, network);
+    this.phoneNumber = phoneNumber;
+    this.recipientName = recipientName;
+    this.trackingKey = trackingKey;
+    this.updatedAt = dateToUTC(updatedAt);
+  }
+
+  static fromObject = ({ amount, descriptor, id, network, status, ...obj }) =>
+    new WhatsAppTransfer({
+      amount,
+      descriptor,
+      id,
+      network,
+      status,
+      createdAt: obj.created_at,
+      claimUrl: obj.claim_url,
+      destinationUri: obj.destination_uri,
+      expiresAt: obj.expires_at,
+      phoneNumber: obj.phone_number,
+      recipientName: obj.recipient_name,
+      trackingKey: obj.tracking_key,
+      updatedAt: obj.updated_at,
+      userId: obj.user_id,
+    });
+}
+
+class MixinBuilder {
+  constructor(superclass) {
+    this.superclass = superclass;
+  }
+
+  with(...mixins) {
+    return mixins.reduce((c, mixin) => mixin(c), this.superclass);
+  }
+}
+
+const mix = (superclass) => new MixinBuilder(superclass);
+
+const getModelFromPath = (path, obj) => {
+  const mapper = {
+    accounts: () => Account.fromObject(obj),
+    api_keys: () => ApiKey.fromObject(obj),
+    arpc: () => Arpc.fromObject(obj),
+    balance_entries: () => BalanceEntry.fromObject(obj),
+    bill_payments: () => BillPayment.fromObject(obj),
+    cards: () => Card.fromObject(obj),
+    card_activations: () => CardActivation.fromObject(obj),
+    card_transactions: () => CardTransaction.fromObject(obj),
+    card_validations: () => CardValidation.fromObject(obj),
+    commissions: () => Commission.fromObject(obj),
+    deposits: () => Deposit.fromObject(obj),
+    login_tokens: () => LoginToken.fromObject(obj),
+    savings: () => Saving.fromObject(obj),
+    service_providers: () => ServiceProvider.fromObject(obj),
+    statements: () => Statement.fromObject(obj),
+    transfers: () => Transfer.fromObject(obj),
+    user_credentials: () => UserCredential.fromObject(obj),
+    user_logins: () => UserLogin.fromObject(obj),
+    wallet_transactions: () => WalletTransaction.fromObject(obj),
+    whatsapp_transfers: () => WhatsAppTransfer.fromObject(obj),
+  };
+
+  return mapper[path]();
+};
+
+const getResource = (uri) => {
+  if (uri === null || uri === '') return null;
+  const regExp = '/(.*?)/';
+  const matches = uri.match(regExp);
+  if (matches === null) return null;
+  return matches[0].replaceAll('/', '');
+};
+
+class Resource {
+  constructor(path, QueryParams, client) {
+    this.path = path;
+    this.QueryParams = QueryParams;
+    this.client = client;
+  }
+}
+
+const Retrievable = (SuperClass) =>
+  class Retrievable extends SuperClass {
+    async retrieve(id) {
+      const response = await this.client.get({
+        endpoint: `/${this.path}/${id}`,
+      });
+      return getModelFromPath(this.path, response);
+    }
+  };
+
+const Creatable = (SuperClass) =>
+  class Creatable extends SuperClass {
+    async _create(data) {
+      const response = await this.client.post({
+        endpoint: `/${this.path}`,
+        data,
+      });
+      return getModelFromPath(this.path, response);
+    }
+  };
+
+const Updateable = (SuperClass) =>
+  class Updateable extends SuperClass {
+    async _update(id, data) {
+      const response = await this.client.patch({
+        endpoint: `/${this.path}/${id}`,
+        data,
+      });
+      const model = getModelFromPath(this.path, response);
+      return model;
+    }
+  };
+
+const Deactivable = (SuperClass) =>
+  class Deactivable extends SuperClass {
+    async _deactivate(id, data) {
+      const response = await this.client.delete({
+        endpoint: `/${this.path}/${id}`,
+        data,
+      });
+      const model = getModelFromPath(this.path, response);
+      return model;
+    }
+  };
+
+const Downlodable = (SuperClass) =>
+  class Downlodable extends SuperClass {
+    async _download(id, format) {
+      const byteString = await this.client.get({
+        endpoint: `/${this.path}/${id}`,
+        format,
+      });
+      return byteString;
+    }
+  };
+
+const Queryable = (SuperClass) =>
+  class Queryable extends SuperClass {
+    async one(queryParams = new this.QueryParams({})) {
+      const { items } = await this.client.get({
+        endpoint: `/${this.path}`,
+        params: queryParams.toParams(),
+      });
+
+      if (!items || !items.length) throw new NoResultFound();
+      if (items.length > 1) throw new MultipleResultsFound();
+
+      const [item] = items;
+      const model = getModelFromPath(this.path, item);
+      return model;
+    }
+
+    async first(queryParams = new this.QueryParams({})) {
+      const { items } = await this.client.get({
+        endpoint: `/${this.path}`,
+        params: queryParams.toParams(),
+      });
+
+      if (!items || !items[0]) return null;
+
+      const [item] = items;
+      const model = getModelFromPath(this.path, item);
+      return model;
+    }
+
+    async count(queryParams = new this.QueryParams({})) {
+      const qP = queryParams;
+      qP.count = true;
+      const { count } = await this.client.get({
+        endpoint: `/${this.path}`,
+        params: queryParams.toParams(),
+      });
+      return count || 0;
+    }
+
+    async *all(queryParams = new this.QueryParams({})) {
+      let nextPageUri = `/${this.path}?${queryParams.toQueryString()}`;
+      while (nextPageUri) {
+        // eslint-disable-next-line no-await-in-loop
+        const page = await this.client.get({ endpoint: nextPageUri });
+        if (page.items) {
+          // eslint-disable-next-line no-restricted-syntax
+          for (const item of page.items) {
+            const model = getModelFromPath(this.path, item);
+            yield model;
+          }
+        }
+        nextPageUri = page.next_page_uri;
+      }
+    }
+  };
+
+class AccountResource extends mix(Resource).with(Queryable, Retrievable) {
+  constructor(client) {
+    super('accounts', AccountQuery, client);
+  }
+}
+
+class ApiKeyResource extends mix(Resource).with(
+  Creatable,
+  Deactivable,
+  Queryable,
+  Retrievable,
+  Updateable,
+) {
+  constructor(client) {
+    super('api_keys', ApiKeyQuery, client);
+  }
+
+  async create() {
+    const apiKey = await this._create();
+    return apiKey;
+  }
+
+  async deactivate(apiKeyId, minutes = 0) {
+    const apiKey = await this._deactivate(apiKeyId, { minutes });
+    return apiKey;
+  }
+
+  async update(apiKeyId, metadata, userId) {
+    const request = new ApiKeyUpdateRequest(userId, metadata);
+    const apiKey = await this._update(apiKeyId, request.toCleanObject());
+    return apiKey;
+  }
+}
+
+class ArpcResource extends mix(Resource).with(Creatable) {
+  constructor(client) {
+    super('arpc', Object, client);
+  }
+
+  async create({
+    number,
+    arqc,
+    arpcMethod,
+    transactionData,
+    responseCode,
+    transactionCounter,
+    panSequence,
+    uniqueNumber,
+    trackDataMethod,
+  }) {
+    const request = new ArpcRequest({
+      number,
+      arqc,
+      arpcMethod,
+      transactionData,
+      responseCode,
+      transactionCounter,
+      panSequence,
+      uniqueNumber,
+      trackDataMethod,
+    });
+    const arpc = await this._create(request.toObject());
+    return arpc;
+  }
+}
+
+class BalanceEntryResource extends mix(Resource).with(Queryable, Retrievable) {
+  constructor(client) {
+    super('balance_entries', BalanceEntryQuery, client);
+  }
+
+  async relatedTransaction(relatedTransactionUri) {
+    const resource = getResource(relatedTransactionUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get({
+      endpoint: relatedTransactionUri,
+    });
+    return getModelFromPath(`${resource}`, response);
+  }
+
+  async fundingInstrument(fundingInstrumentUri) {
+    const resource = getResource(fundingInstrumentUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get({
+      endpoint: fundingInstrumentUri,
+    });
+    return getModelFromPath(`${resource}`, response);
+  }
+}
+
+class BillPaymentResource extends mix(Resource).with(Queryable, Retrievable) {
+  constructor(client) {
+    super('bill_payments', BillPaymentQuery, client);
+  }
+
+  async serviceProvider(providerUri) {
+    const resource = getResource(providerUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get({ endpoint: providerUri });
+    return getModelFromPath(`${resource}`, response);
+  }
+}
+
+class CardActivationResource extends mix(Resource).with(Creatable) {
+  constructor(client) {
+    super('card_activations', Object, client);
+  }
+
+  async create({ number, expMonth, expYear, cvv2 }) {
+    const request = new CardActivationRequest(number, expMonth, expYear, cvv2);
+    const activation = await this._create(request.toCleanObject());
+    return activation;
+  }
+
+  async card(cardUri) {
+    if (!cardUri) return null;
+    const response = await this.client.get({ endpoint: cardUri });
+    return Card.fromObject(response);
+  }
+}
+
+class CardResource extends mix(Resource).with(
+  Creatable,
+  Deactivable,
+  Queryable,
+  Retrievable,
+  Updateable,
+) {
+  constructor(client) {
+    super('cards', CardsQuery, client);
+  }
+
+  async create(userId, issuer, fundingType) {
+    const request = new CardRequest(userId, issuer, fundingType);
+    const card = await this._create(request.toCleanObject());
+    return card;
+  }
+
+  async deactivate(cardId) {
+    const response = await this._deactivate(cardId);
+    return response;
+  }
+
+  async update(cardId, status, pinBlock) {
+    const request = new CardUpdateRequest(status, pinBlock);
+    const card = await this._update(cardId, request.toCleanObject());
+    return card;
+  }
+}
+
+class CardTransactionResource extends mix(Resource).with(
+  Queryable,
+  Retrievable,
+) {
+  constructor(client) {
+    super('card_transactions', CardTransactionQuery, client);
+  }
+
+  async relatedCard(relatedCardUri) {
+    const resource = getResource(relatedCardUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get({
+      endpoint: relatedCardUri,
+    });
+    return getModelFromPath(`${resource}`, response);
+  }
+}
+
+class CardValidationResource extends mix(Resource).with(Creatable) {
+  constructor(client) {
+    super('card_validations', Object, client);
+  }
+
+  async create({
+    cvv,
+    cvv2,
+    expMonth,
+    expYear,
+    icvv,
+    number,
+    pinBlock,
+    pinAttemptsExceeded,
+  }) {
+    const request = new CardValidationRequest({
+      cvv,
+      cvv2,
+      expMonth,
+      expYear,
+      icvv,
+      number,
+      pinBlock,
+      pinAttemptsExceeded,
+    });
+    const validation = await this._create(request.toCleanObject());
+    return validation;
+  }
+
+  async card(cardUri) {
+    if (!cardUri) return null;
+    const response = await this.client.get({ endpoint: cardUri });
+    return Card.fromObject(response);
+  }
+}
+
+class CommissionResource extends mix(Resource).with(Queryable, Retrievable) {
+  constructor(client) {
+    super('commissions', QueryParams, client);
+  }
+
+  async relatedTransaction(relatedTransactionUri) {
+    const resource = getResource(relatedTransactionUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get(relatedTransactionUri);
+    return getModelFromPath(`${resource}`, response);
+  }
+}
+
+class DepositResource extends mix(Resource).with(Queryable, Retrievable) {
+  constructor(client) {
+    super('deposits', DepositQuery, client);
+  }
+
+  async source(sourceUri) {
+    const response = await this.client.get({ endpoint: sourceUri });
+    return Account.fromObject(response);
+  }
+}
+
+class LoginTokenResource extends mix(Resource).with(Creatable) {
+  constructor(client) {
+    super('login_tokens', Object, client);
+  }
+
+  async create() {
+    const loginToken = await this._create();
+    return loginToken;
+  }
+}
+
+class SavingResource extends mix(Resource).with(
+  Creatable,
+  Deactivable,
+  Queryable,
+  Retrievable,
+  Updateable,
+) {
+  constructor(client) {
+    super('savings', WalletQuery, client);
+  }
+
+  async create(category, goalAmount, goalDate, name) {
+    const request = new SavingRequest(category, goalAmount, goalDate, name);
+    const saving = await this._create(request.toObject());
+    return saving;
+  }
+
+  async deactivate(savingId) {
+    const response = await this._deactivate(savingId);
+    return response;
+  }
+
+  async update(savingId, category, goalAmount, goalDate, name) {
+    const request = new SavingRequest(category, goalAmount, goalDate, name);
+    const saving = await this._update(savingId, request.toObject());
+    return saving;
+  }
+}
+
+class ServiceProviderResource extends mix(Resource).with(
+  Queryable,
+  Retrievable,
+) {
+  constructor(client) {
+    super('service_providers', QueryParams, client);
+  }
+}
+
+class StatementResource extends mix(Resource).with(Downlodable, Queryable) {
+  constructor(client) {
+    super('statements', StatementQuery, client);
+  }
+
+  async pdf(id) {
+    const byteString = await this._download(id, FileFormat.Pdf);
+    return byteString;
+  }
+
+  async xml(id) {
+    const byteString = await this._download(id, FileFormat.Xml);
+    return byteString;
+  }
+}
+
+class TransferResource extends mix(Resource).with(
+  Creatable,
+  Queryable,
+  Retrievable,
+) {
+  constructor(client) {
+    super('transfers', TransferQuery, client);
+  }
+
+  async destination(destinationUri) {
+    const response = await this.client.get({
+      endpoint: destinationUri,
+    });
+    return Account.fromObject(response);
+  }
+
+  async create({
+    accountNumber,
+    amount,
+    descriptor,
+    recipientName,
+    idempotencyKey,
+  }) {
+    const key =
+      idempotencyKey ||
+      this.constructor._genIdempotencyKey(accountNumber, amount);
+    const request = new TransferRequest(
+      accountNumber,
+      amount,
+      descriptor,
+      key,
+      recipientName,
+    );
+    const transfer = await this._create(request.toCleanObject());
+    return transfer;
+  }
+
+  async createMany(requests) {
+    if (!requests || !Array.isArray(requests) || !requests.length) return {};
+    const transfers = { submitted: [], errors: [] };
+
+    await Promise.all(
+      requests.map(
+        async ({
+          accountNumber,
+          amount,
+          descriptor,
+          idempotencyKey,
+          recipientName,
+        }) => {
+          const actualRequest = new TransferRequest(
+            accountNumber,
+            amount,
+            descriptor,
+            idempotencyKey ||
+              this.constructor._genIdempotencyKey(accountNumber, amount),
+            recipientName,
+          );
+          let transfer;
+          try {
+            transfer = await this._create(actualRequest.toCleanObject());
+          } catch (error) {
+            transfers.errors.push({ actualRequest, error });
+            return;
+          }
+          transfers.submitted.push(transfer);
+        },
+      ),
+    );
+
+    return transfers;
+  }
+
+  static _genIdempotencyKey(accountNumber, amount) {
+    const [date] = dateToUTC(Date.now()).toISOString().split('T');
+    return `${date}:${accountNumber}:${amount}`;
+  }
+}
+
+class UserCredentialResource extends mix(Resource).with(Creatable, Updateable) {
+  constructor(client) {
+    super('user_credentials', Object, client);
+  }
+
+  async create(password) {
+    const request = new UserCredentialRequest(password);
+    const credential = await this._create(request.toObject());
+    return credential;
+  }
+
+  async update({ isActive, password, userId = 'me' }) {
+    const request = new UserCredentialUpdateRequest(password, isActive);
+    const credential = await this._update(userId, request.toCleanObject());
+    return credential;
+  }
+}
+
+class UserLoginResource extends mix(Resource).with(Creatable, Deactivable) {
+  constructor(client) {
+    super('user_logins', Object, client);
+    this.loginIdInHeaders = null;
+  }
+
+  async create(password, userId) {
+    const request = new UserLoginRequest(password, userId);
+    const userLogin = await this._create(request.toObject());
+    if (!userLogin.success) throw new InvalidPassword();
+
+    // Set login id to headers
+    this.loginIdInHeaders = this.client.addHeadersToRequest({
+      'X-Cuenca-LoginId': userLogin.id,
+    });
+
+    return userLogin;
+  }
+
+  async logOut(userId = 'me') {
+    await this._deactivate(userId, {});
+
+    // Remove current login id from headers
+    this.loginIdInHeaders && this.loginIdInHeaders.eject();
+
+    return true;
+  }
+}
+
+class WalletTransactionsResource extends mix(Resource).with(
+  Creatable,
+  Queryable,
+  Retrievable,
+) {
+  constructor(client) {
+    super('wallet_transactions', WalletTransactionQuery, client);
+  }
+
+  async create(amount, transactionType, walletUri) {
+    const request = new WalletTransactionRequest(
+      amount,
+      transactionType,
+      walletUri,
+    );
+    const walletTransaction = await this._create(request.toObject());
+    return walletTransaction;
+  }
+
+  async realtedWallet(walletUri) {
+    const resource = getResource(walletUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get(walletUri);
+    return getModelFromPath(`${resource}`, response);
+  }
+}
+
+class WhatsAppTransferResource extends mix(Resource).with(
+  Queryable,
+  Retrievable,
+) {
+  constructor(client) {
+    super('whatsapp_transfers', QueryParams, client);
+  }
+
+  async accountDestination(destinationUri) {
+    const resource = getResource(destinationUri);
+    if (resource == null) return null;
+
+    const response = await this.client.get(destinationUri);
+    return getModelFromPath(`${resource}`, response);
+  }
+}
+
+class Cuenca {
+  constructor(apiKey, apiSecret, phase = Phase.Sandbox) {
+    this.client = new Client({ apiKey, apiSecret, phase });
+    this.withClient(this.client);
+  }
+
+  withClient(client) {
+    this.accounts = new AccountResource(client);
+    this.apiKeys = new ApiKeyResource(client);
+    this.balanceEntries = new BalanceEntryResource(client);
+    this.billPayments = new BillPaymentResource(client);
+    this.cardActivations = new CardActivationResource(client);
+    this.cards = new CardResource(client);
+    this.cardTransactions = new CardTransactionResource(client);
+    this.cardValidations = new CardValidationResource(client);
+    this.commissions = new CommissionResource(client);
+    this.deposits = new DepositResource(client);
+    this.loginTokens = new LoginTokenResource(client);
+    this.savings = new SavingResource(client);
+    this.serviceProviders = new ServiceProviderResource(client);
+    this.statements = new StatementResource(client);
+    this.transfers = new TransferResource(client);
+    this.userCredentials = new UserCredentialResource(client);
+    this.userLogins = new UserLoginResource(client);
+    this.walletTransactions = new WalletTransactionsResource(client);
+    this.whatsAppTransfers = new WhatsAppTransferResource(client);
+  }
+}
+
+export { Cuenca };