@cuenca-mx/cuenca-js 0.0.14-dev9 → 1.0.0

package/build/{identities-240756bd.cjs → vulnerableActivity-88488ee4.cjs}

@@ -1,26 +1,7 @@
 'use strict';
 
 var errors_index = require('./errors/index.cjs');
-var data = require('./data-92aab1cc.cjs');
-
-class PageSize {
-  constructor(size) {
-    this.maxSize = 100;
-    this._ps = size;
-  }
-
-  get size() {
-    return this._pageSize;
-  }
-
-  set _ps(value) {
-    let validatedPageSize = this.maxSize;
-    if (value && value > 0 && value <= this.maxSize) {
-      validatedPageSize = value;
-    }
-    this._pageSize = validatedPageSize;
-  }
-}
+var data = require('./data-6c2897da.cjs');
 
 class QueryParams {
   constructor({
@@ -45,10 +26,9 @@ class QueryParams {
     return this._limit;
   }
 
-  // Validator for limit
   set _lmt(value) {
     let validatedValue = null;
-    if (value && value >= 0) {
+    if (typeof value === 'number' && value >= 0) {
       validatedValue = value;
     }
     this._limit = validatedValue;
@@ -92,162 +72,150 @@ class AccountQuery extends QueryParams {
   }
 }
 
-class ApiKeyQuery extends QueryParams {
-  constructor({ active, ...args }) {
+class AlertQuery extends QueryParams {
+  constructor({
+    agent,
+    comments,
+    committeeMeetingDate,
+    count,
+    hasQuestionnaire,
+    inProcess,
+    status,
+    typeOfFilter,
+    transactionDate,
+    ...args
+  }) {
     super(args);
-    this.active = active;
+    this.agent = agent;
+    this.comments = comments;
+    this.committeeMeetingDate = committeeMeetingDate;
+    this.count = count;
+    this.hasQuestionnaire = hasQuestionnaire;
+    this.inProcess = inProcess;
+    this.status = status;
+    this.typeOfFilter = typeOfFilter;
+    this.transactionDate = transactionDate;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      active: this.active,
+      agent: this.agent,
+      comments: this.comments,
+      committee_meeting_date: this.committeeMeetingDate,
+      count: this.count,
+      has_questionnaire: this.hasQuestionnaire,
+      in_process: this.inProcess,
+      status: this.status,
+      transaction_date: this.transactionDate,
+      type_of_filter: this.typeOfFilter,
     });
   }
 }
 
-class TransactionQuery extends QueryParams {
-  constructor({ status, ...args }) {
+class ApiKeyQuery extends QueryParams {
+  constructor({ active, ...args }) {
     super(args);
-    this.status = status;
+    this.active = active;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      status: this.status,
+      active: this.active,
     });
   }
 }
 
-class DepositQuery extends TransactionQuery {
-  constructor({ trackingKey, network, ...args }) {
+class BalanceEntryQuery extends QueryParams {
+  constructor({
+    fundingInstrumentUri,
+    count = false,
+    walletId = 'default',
+    ...args
+  }) {
     super(args);
-    this.trackingKey = trackingKey;
-    this.network = network;
+    this.fundingInstrumentUri = fundingInstrumentUri;
+    this.count = count;
+    this.walletId = walletId;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      tracking_key: this.trackingKey,
-      network: this.network,
+      wallet_id: this.walletId,
+      funding_instrument_uri: this.fundingInstrumentUri,
+      count: this.count,
     });
   }
 }
 
-class TransferQuery extends TransactionQuery {
-  constructor({
-    accountNumber,
-    idempotencyKey,
-    trackingKey,
-    network,
-    ...args
-  }) {
+class BillPaymentQuery extends QueryParams {
+  constructor({ accountNumber, ...args }) {
     super(args);
     this.accountNumber = accountNumber;
-    this.idempotencyKey = idempotencyKey;
-    this.trackingKey = trackingKey;
-    this.network = network;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
       account_number: this.accountNumber,
-      idempotency_key: this.idempotencyKey,
-      tracking_key: this.trackingKey,
-      network: this.network,
     });
   }
 }
 
-class BalanceEntryQuery extends QueryParams {
-  constructor({
-    fundingInstrumentUri,
-    count = false,
-    walletId = 'default',
-    ...args
-  }) {
+class BridgeAccountQuery extends QueryParams {
+  constructor({ emailAddress, ...args }) {
     super(args);
-    this.fundingInstrumentUri = fundingInstrumentUri;
-    this.count = count;
-    this.walletId = walletId;
+    this.emailAddress = emailAddress;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      wallet_id: this.walletId,
-      funding_instrument_uri: this.fundingInstrumentUri,
-      count: this.count,
+      email_address: this.emailAddress,
     });
   }
 }
 
-class AlertQuery extends QueryParams {
-  constructor({
-    aggent,
-    comments,
-    committeeMeetingDate,
-    count,
-    hasQuestionnaire,
-    inProcess,
-    status,
-    typeOfFilter,
-    transactionDate,
-    ...args
-  }) {
+class BridgeBankAccountQuery extends QueryParams {
+  constructor({ accountId, ...args }) {
     super(args);
-    this.aggent = aggent;
-    this.comments = comments;
-    this.committeeMeetingDate = committeeMeetingDate;
-    this.count = count;
-    this.hasQuestionnaire = hasQuestionnaire;
-    this.inProcess = inProcess;
-    this.status = status;
-    this.typeOfFilter = typeOfFilter;
-    this.transactionDate = transactionDate;
+    this.accountId = accountId;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      aggent: this.aggent,
-      comments: this.comments,
-      committee_meeting_date: this.committeeMeetingDate,
-      count: this.count,
-      has_questionnaire: this.hasQuestionnaire,
-      in_process: this.inProcess,
-      status: this.status,
-      transaction_date: this.transactionDate,
-      type_of_filter: this.typeOfFilter,
+      account_id: this.accountId,
     });
   }
 }
 
-class BillPaymentQuery extends QueryParams {
-  constructor({ accountNumber, ...args }) {
+class BridgeQuery extends QueryParams {
+  constructor({ accountId, ...args }) {
     super(args);
-    this.accountNumber = accountNumber;
+    this.accountId = accountId;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      account_number: this.accountNumber,
+      account: this.accountId,
     });
   }
 }
 
-class CardTransactionQuery extends QueryParams {
-  constructor({ cardUri, ...args }) {
+class BridgeTransactionQuery extends BridgeQuery {
+  constructor({ status, type, ...args }) {
     super(args);
-    this.cardUri = cardUri;
+    this.status = status;
+    this.type = type;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      card_uri: this.cardUri,
+      status: this.status,
+      type: this.type,
     });
   }
 }
 
 class CardsQuery extends QueryParams {
-  constructor({ cardUri, count = false, ...args }) {
+  constructor({ cardUri, count = false, ...args } = {}) {
     super(args);
     this.cardUri = cardUri;
     this.count = count;
@@ -261,75 +229,98 @@ class CardsQuery extends QueryParams {
   }
 }
 
-class WalletTransactionQuery extends QueryParams {
-  constructor({ walletUri, ...args }) {
+class CardTransactionQuery extends QueryParams {
+  constructor({ cardUri, ...args }) {
     super(args);
-    this.walletUri = walletUri;
+    this.cardUri = cardUri;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      wallet_uri: this.walletUri,
+      card_uri: this.cardUri,
     });
   }
 }
 
-class UserQuery extends QueryParams {
-  constructor({ emailAddress, hasCurpDocument, phoneNumber, status, ...args }) {
+class TransactionQuery extends QueryParams {
+  constructor({ status, ...args }) {
     super(args);
-    this.emailAddress = emailAddress;
-    this.hasCurpDocument = hasCurpDocument;
-    this.phoneNumber = phoneNumber;
     this.status = status;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      email_address: this.emailAddress,
-      has_curp_document: this.hasCurpDocument,
-      phone_number: this.phoneNumber,
       status: this.status,
     });
   }
 }
 
-class WalletQuery extends QueryParams {
-  constructor({ active, ...args }) {
+class DepositQuery extends TransactionQuery {
+  constructor({ trackingKey, network, ...args }) {
     super(args);
-    this.active = active;
+    this.trackingKey = trackingKey;
+    this.network = network;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      active: this.active,
+      tracking_key: this.trackingKey,
+      network: this.network,
+    });
+  }
+}
+
+class PartnerQuery extends QueryParams {
+  constructor({ emailAddress, ...args }) {
+    super(args);
+    this.emailAddress = emailAddress;
+  }
+
+  toObject() {
+    return Object.assign(super.toObject(), {
+      email_address: this.emailAddress,
     });
   }
 }
 
 class StatementQuery extends QueryParams {
-  constructor({ month, year, ...args }) {
+  constructor({ month, year, ...args } = {}) {
     super(args);
-    this.d = { month, year };
+    if (month !== undefined && year !== undefined) {
+      this.d = { month, year };
+    }
   }
 
   get month() {
-    return this._date.month;
+    return this._date?.month;
   }
 
   get year() {
-    return this._date.year;
+    return this._date?.year;
   }
 
   set d({ month, year }) {
-    const now = data.dateToUTC(Date.now());
-    now.setUTCDate(1);
-    const date = data.dateToUTC(`${year}-${month}-01`);
-    if (date.getTime() >= now.getTime()) {
+    const m = Number(month);
+    const y = Number(year);
+    if (!Number.isInteger(m) || m < 1 || m > 12) {
+      throw new errors_index.ValidationError('month must be an integer between 1 and 12');
+    }
+    if (!Number.isInteger(y) || y < 1900 || y > 9999) {
       throw new errors_index.ValidationError(
-        `${year}-${month} is not a valid year-month pair`,
+        'year must be an integer between 1900 and 9999',
       );
     }
-    this._date = { month, year };
+    const candidate = new Date(Date.UTC(y, m - 1, 1));
+    const nowUtc = new Date();
+    const currentMonthStart = new Date(
+      Date.UTC(nowUtc.getUTCFullYear(), nowUtc.getUTCMonth(), 1),
+    );
+    if (candidate.getTime() >= currentMonthStart.getTime()) {
+      const mm = String(m).padStart(2, '0');
+      throw new errors_index.ValidationError(`${y}-${mm} is not a valid year-month pair`);
+    }
+
+    this._date = { month: m, year: y };
   }
 
   toObject() {
@@ -340,74 +331,191 @@ class StatementQuery extends QueryParams {
   }
 }
 
-class BridgeAccountQuery extends QueryParams {
-  constructor({ emailAddress, ...args }) {
+class TransferQuery extends TransactionQuery {
+  constructor({
+    accountNumber,
+    idempotencyKey,
+    trackingKey,
+    network,
+    ...args
+  }) {
     super(args);
-    this.emailAddress = emailAddress;
+    this.accountNumber = accountNumber;
+    this.idempotencyKey = idempotencyKey;
+    this.trackingKey = trackingKey;
+    this.network = network;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      email_address: this.emailAddress,
+      account_number: this.accountNumber,
+      idempotency_key: this.idempotencyKey,
+      tracking_key: this.trackingKey,
+      network: this.network,
     });
   }
 }
 
-class BridgeQuery extends QueryParams {
-  constructor({ accountId, ...args }) {
+class UserQuery extends QueryParams {
+  constructor({
+    emailAddress,
+    hasCurpDocument,
+    phoneNumber,
+    status,
+    ...args
+  } = {}) {
     super(args);
-    this.accountId = accountId;
+    this.emailAddress = emailAddress;
+    this.hasCurpDocument = hasCurpDocument;
+    this.phoneNumber = phoneNumber;
+    this.status = status;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      account: this.accountId,
+      email_address: this.emailAddress,
+      has_curp_document: this.hasCurpDocument,
+      phone_number: this.phoneNumber,
+      status: this.status,
     });
   }
 }
 
-class BridgeBankAccountQuery extends QueryParams {
-  constructor({ accountId, ...args }) {
+class WalletQuery extends QueryParams {
+  constructor({ active, ...args }) {
     super(args);
-    this.accountId = accountId;
+    this.active = active;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      account_id: this.accountId,
+      active: this.active,
     });
   }
 }
 
-class BridgeTransactionQuery extends BridgeQuery {
-  constructor({ status, type, ...args }) {
+class WalletTransactionQuery extends QueryParams {
+  constructor({ walletUri, ...args }) {
     super(args);
-    this.status = status;
-    this.type = type;
+    this.walletUri = walletUri;
   }
 
   toObject() {
     return Object.assign(super.toObject(), {
-      status: this.status,
-      type: this.type,
+      wallet_uri: this.walletUri,
     });
   }
 }
 
-class TOSAgreements {
-  constructor({ ip, location, type, version }) {
-    this.ip = ip;
-    this.location = location;
-    this.type = type;
-    this.version = version;
+class Address {
+  constructor({
+    city,
+    colonia,
+    country,
+    createdAt,
+    extNumber,
+    fullName,
+    intNumber,
+    postalCode,
+    state,
+    street,
+  }) {
+    this.city = city;
+    this.colonia = colonia;
+    this.country = country;
+    this.createdAt = data.dateToUTC(createdAt);
+    this.extNumber = extNumber;
+    this.fullName = fullName;
+    this.intNumber = intNumber;
+    this.postalCode = postalCode;
+    this.state = state;
+    this.street = street;
   }
 
-  static fromObject = ({ ip, location, type, version }) =>
-    new TOSAgreements({
-      ip,
-      location,
-      type,
-      version,
+  static fromObject = ({ city, colonia, country, state, street, ...obj }) =>
+    new Address({
+      city,
+      colonia,
+      country,
+      state,
+      street,
+      createdAt: obj.created_at,
+      extNumber: obj.ext_number,
+      fullName: obj.full_name,
+      intNumber: obj.int_number,
+      postalCode: obj.postal_code,
+    });
+}
+
+class AlertLog {
+  constructor({ agent, createdAt, status, updatedAt, comments }) {
+    this.agent = agent;
+    this.comments = comments;
+    this.createdAt = data.dateToUTC(createdAt);
+    this.updatedAt = data.dateToUTC(updatedAt);
+    this.status = data.enumValueFromString(data.AlertStatus, status);
+  }
+
+  static fromObject = ({ agent, comments, status, ...obj }) =>
+    new AlertLog({
+      agent,
+      comments,
+      status,
+      createdAt: obj.created_at,
+      updatedAt: obj.updated_at,
+    });
+}
+
+class Audit {
+  constructor({ hasAudit, auditProvider, auditDate, auditComments }) {
+    this.hasAudit = hasAudit;
+    this.auditProvider = auditProvider;
+    this.auditDate = data.dateToUTC(auditDate);
+    this.auditComments = auditComments;
+  }
+
+  static fromObject = ({ ...obj }) =>
+    new Audit({
+      hasAudit: obj.has_audit,
+      auditProvider: obj.audit_provider,
+      auditDate: obj.audit_date,
+      auditComments: obj.audit_comments,
+    });
+}
+
+class BusinessDetails {
+  constructor({
+    accountUsageDescription = null,
+    businessDescription = null,
+  } = {}) {
+    this.accountUsageDescription = accountUsageDescription;
+    this.businessDescription = businessDescription;
+  }
+
+  static fromObject = ({ ...obj } = {}) =>
+    new BusinessDetails({
+      accountUsageDescription: obj.account_usage_description,
+      businessDescription: obj.business_description,
+    });
+
+  toObject() {
+    return {
+      account_usage_description: this.accountUsageDescription,
+      business_description: this.businessDescription,
+    };
+  }
+}
+
+class ExternalAccount {
+  constructor({ bank, account }) {
+    this.bank = bank;
+    this.account = account;
+  }
+
+  static fromObject = ({ account, bank }) =>
+    new ExternalAccount({
+      bank,
+      account,
     });
 }
 
@@ -454,100 +562,252 @@ class KYCFile {
     });
 }
 
-class Address {
+class License {
   constructor({
-    city,
-    colonia,
-    country,
-    createdAt,
-    extNumber,
-    fullName,
-    intNumber,
-    postalCode,
-    state,
-    street,
+    licenseRequired = false,
+    supervisoryEntity = null,
+    licenseType = null,
+    licenseDate = null,
+  } = {}) {
+    this.licenseRequired = licenseRequired;
+    this.supervisoryEntity = supervisoryEntity;
+    this.licenseType = licenseType;
+    this.licenseDate = licenseDate ? data.dateToUTC(licenseDate) : null;
+  }
+
+  static fromObject = ({ ...obj } = {}) =>
+    new License({
+      licenseRequired: obj.license_required,
+      supervisoryEntity: obj.supervisory_entity,
+      licenseType: obj.license_type,
+      licenseDate: obj.license_date,
+    });
+}
+
+class PhysicalPerson {
+  constructor({ names, curp, rfc, firstSurname, secondSurname }) {
+    this.names = names;
+    this.curp = curp;
+    this.rfc = rfc;
+    this.firstSurname = firstSurname;
+    this.secondSurname = secondSurname;
+  }
+
+  static fromObject = ({ names, curp, rfc, ...obj }) => {
+    return new PhysicalPerson({
+      names,
+      curp,
+      rfc,
+      firstSurname: obj.first_surname,
+      secondSurname: obj.second_surname,
+    });
+  };
+
+  toObject() {
+    return {
+      names: this.names,
+      curp: this.curp,
+      rfc: this.rfc,
+      first_surname: this.firstSurname,
+      second_surname: this.secondSurname,
+    };
+  }
+}
+
+class LegalRepresentatives extends PhysicalPerson {
+  constructor({
+    names,
+    curp,
+    rfc,
+    firstSurname,
+    secondSurname,
+    job,
+    phoneNumber,
+    emailAddress,
+    address,
   }) {
-    this.city = city;
-    this.colonia = colonia;
-    this.country = country;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.extNumber = extNumber;
-    this.fullName = fullName;
-    this.intNumber = intNumber;
-    this.postalCode = postalCode;
-    this.state = state;
-    this.street = street;
+    super({ names, curp, rfc, firstSurname, secondSurname });
+    this.job = job;
+    this.phoneNumber = phoneNumber;
+    this.emailAddress = emailAddress;
+    this.address = address;
   }
 
-  static fromObject = ({ city, colonia, country, state, street, ...obj }) =>
-    new Address({
-      city,
-      colonia,
-      country,
-      state,
-      street,
-      createdAt: obj.created_at,
-      extNumber: obj.ext_number,
-      fullName: obj.full_name,
-      intNumber: obj.int_number,
-      postalCode: obj.postal_code,
+  get address() {
+    return this._address;
+  }
+
+  set address(value) {
+    if (!value) return;
+    this._address = Address.fromObject(value);
+  }
+
+  static fromObject = ({ job, address, ...obj }) =>
+    new LegalRepresentatives({
+      address,
+      job,
+      phoneNumber: obj.phone_number,
+      emailAddress: obj.email_address,
+      ...PhysicalPerson.fromObject(obj),
     });
 }
 
-class AlertLog {
-  constructor({ aggent, createdAt, status, updatedAt, comments }) {
-    this.aggent = aggent;
-    this.comments = comments;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.status = data.enumValueFromString(data.AlertStatus, status);
+class ShareholderPhysical extends PhysicalPerson {
+  constructor({
+    names,
+    curp,
+    rfc,
+    firstSurname,
+    secondSurname,
+    shareCapital,
+    percentage,
+  }) {
+    super({ names, curp, rfc, firstSurname, secondSurname });
+    this.shareCapital = shareCapital;
+    this.percentage = percentage;
   }
 
-  static fromObject = ({ aggent, comments, status, ...obj }) =>
-    new AlertLog({
-      aggent,
-      comments,
-      status,
-      createdAt: obj.created_at,
-      updatedAt: obj.updated_at,
+  static fromObject = ({ percentage, ...obj }) => {
+    return new ShareholderPhysical({
+      percentage,
+      shareCapital: obj.share_capital,
+      ...PhysicalPerson.fromObject(obj),
     });
+  };
 }
 
-class AlertLogs {
-  constructor(value) {
-    this.changeLog = value.changeLog.map((log) => {
-      return new AlertLog(log);
+class ShareholderMoral {
+  constructor({ name, percentage, shareholders, legalRepresentatives }) {
+    this.name = name;
+    this.percentage = percentage;
+    this.shareholders = shareholders;
+    this.legalRepresentatives = legalRepresentatives;
+  }
+
+  get shareholders() {
+    return this._shareholders;
+  }
+
+  set shareholders(value) {
+    if (!value) return;
+    this._shareholders = value.map((sh) => ShareholderPhysical.fromObject(sh));
+  }
+
+  get legalRepresentatives() {
+    return this._legalRepresentatives;
+  }
+
+  set legalRepresentatives(value) {
+    if (!value) return;
+    this._legalRepresentatives = value.map((lr) =>
+      LegalRepresentatives.fromObject(lr),
+    );
+  }
+
+  static fromObject = ({ name, percentage, shareholders, ...obj }) => {
+    return new ShareholderMoral({
+      name,
+      percentage,
+      shareholders: shareholders || [],
+      legalRepresentatives: obj.legal_representatives || [],
     });
+  };
+}
+
+class TransactionalProfileServices {
+  constructor({
+    speiTransfersNum,
+    speiTransfersAmount,
+    internalTransfersNum,
+    internalTransfersAmount,
+  } = {}) {
+    this.speiTransfersNum = speiTransfersNum;
+    this.speiTransfersAmount = speiTransfersAmount;
+    this.internalTransfersNum = internalTransfersNum;
+    this.internalTransfersAmount = internalTransfersAmount;
+  }
+
+  static fromObject = ({ ...obj } = {}) => {
+    const response = new TransactionalProfileServices({
+      speiTransfersNum: obj.spei_transfers_num,
+      speiTransfersAmount: obj.spei_transfers_amount,
+      internalTransfersNum: obj.internal_transfers_num,
+      internalTransfersAmount: obj.internal_transfers_amount,
+    });
+
+    return response;
+  };
+}
+
+class TOSAgreements {
+  constructor({ ip, location, type, version }) {
+    this.ip = ip;
+    this.location = location;
+    this.type = type;
+    this.version = version;
   }
 
-  static fromObject = (value) =>
-    new AlertLogs({
-      changeLog: value.map((log) => AlertLog.fromObject(log)),
+  static fromObject = ({ ip, location, type, version }) =>
+    new TOSAgreements({
+      ip,
+      location,
+      type,
+      version,
+    });
+}
+
+class VulnerableActivity {
+  constructor({
+    isVulnerableActivity,
+    hasSatRegister,
+    satRegisteredDate,
+    isInCompliance,
+  }) {
+    this.isVulnerableActivity = isVulnerableActivity;
+    this.hasSatRegister = hasSatRegister;
+    this.satRegisteredDate = data.dateToUTC(satRegisteredDate);
+    this.isInCompliance = isInCompliance;
+  }
+
+  static fromObject = ({ ...obj }) =>
+    new VulnerableActivity({
+      isVulnerableActivity: obj.is_vulnerable_activity,
+      hasSatRegister: obj.has_sat_register,
+      satRegisteredDate: obj.sat_registered_date,
+      isInCompliance: obj.is_in_compliance,
     });
 }
 
 exports.AccountQuery = AccountQuery;
 exports.Address = Address;
 exports.AlertLog = AlertLog;
-exports.AlertLogs = AlertLogs;
 exports.AlertQuery = AlertQuery;
 exports.ApiKeyQuery = ApiKeyQuery;
+exports.Audit = Audit;
 exports.BalanceEntryQuery = BalanceEntryQuery;
 exports.BillPaymentQuery = BillPaymentQuery;
 exports.BridgeAccountQuery = BridgeAccountQuery;
 exports.BridgeBankAccountQuery = BridgeBankAccountQuery;
 exports.BridgeQuery = BridgeQuery;
 exports.BridgeTransactionQuery = BridgeTransactionQuery;
+exports.BusinessDetails = BusinessDetails;
 exports.CardTransactionQuery = CardTransactionQuery;
 exports.CardsQuery = CardsQuery;
 exports.DepositQuery = DepositQuery;
+exports.ExternalAccount = ExternalAccount;
 exports.KYCFile = KYCFile;
-exports.PageSize = PageSize;
+exports.LegalRepresentatives = LegalRepresentatives;
+exports.License = License;
+exports.PartnerQuery = PartnerQuery;
 exports.QueryParams = QueryParams;
+exports.ShareholderMoral = ShareholderMoral;
 exports.StatementQuery = StatementQuery;
 exports.TOSAgreements = TOSAgreements;
 exports.TransactionQuery = TransactionQuery;
+exports.TransactionalProfileServices = TransactionalProfileServices;
 exports.TransferQuery = TransferQuery;
 exports.UserQuery = UserQuery;
+exports.VerificationError = VerificationError;
+exports.VulnerableActivity = VulnerableActivity;
 exports.WalletQuery = WalletQuery;
 exports.WalletTransactionQuery = WalletTransactionQuery;