@cuenca-mx/cuenca-js 1.2.2 → 2.0.0-dev1

package/build/index.cjs

@@ -2,17 +2,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var axios = require('axios');
 var Buffer = require('buffer');
 var errors_index = require('./errors/index.cjs');
 var jwt_index = require('./jwt/index.cjs');
-var data = require('./data-72c37b60.cjs');
-var vulnerableActivity = require('./vulnerableActivity-7cc1734f.cjs');
-var walletTransactionRequest = require('./walletTransactionRequest-c6a5c64d.cjs');
+var data = require('./data-70e6af8d.cjs');
+var vulnerableActivity = require('./vulnerableActivity-3cb7b0ed.cjs');
+var walletTransactionRequest = require('./walletTransactionRequest-dd13c569.cjs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var Buffer__default = /*#__PURE__*/_interopDefaultLegacy(Buffer);
 
 /* global window */
@@ -26,7 +24,139 @@ const isNode =
 
 const runtimeEnv = { isBrowser, isNode };
 
-const name="@cuenca-mx/cuenca-js";const version="1.2.2";const description="Cuenca client for JS";const main="./build/index.cjs";const module$1="./build/index.mjs";const browser="./build/umd/cuenca.umd.js";const files=["build/**/*"];const exports$1={".":{"import":"./build/index.mjs",require:"./build/index.cjs"},"./errors":{"import":"./build/errors/index.mjs",require:"./build/errors/index.cjs"},"./jwt":{"import":"./build/jwt/index.mjs",require:"./build/jwt/index.cjs"},"./requests":{"import":"./build/requests/index.mjs",require:"./build/requests/index.cjs"},"./types":{"import":"./build/types/index.mjs",require:"./build/types/index.cjs"}};const packageManager="yarn@3.0.2";const type="module";const repository={type:"git",url:"https://github.com/cuenca-mx/cuenca-js.git",directory:"packages/cuenca-js"};const keywords=["cuenca"];const license="MIT";const bugs={url:"https://github.com/cuenca-mx/cuenca-js/issues"};const homepage="https://cuenca.com";const scripts={build:"rm -rf build/ && yarn rollup --config",test:"yarn node --experimental-vm-modules $(yarn bin jest)",publish:"yarn build && yarn npm publish",dev:"rm -rf build/ && yarn rollup --config && yarn node ../example.cjs",example:"yarn node ../example.cjs"};const devDependencies={"@rollup/plugin-json":"^4.1.0","@rollup/plugin-node-resolve":"^13.1.1",jest:"^27.4.5",rollup:"^2.61.1","rollup-plugin-terser":"^7.0.2"};const dependencies={axios:"^0.24.0",buffer:"^6.0.3"};var pkg = {name:name,version:version,description:description,main:main,module:module$1,browser:browser,files:files,exports:exports$1,packageManager:packageManager,type:type,repository:repository,keywords:keywords,license:license,bugs:bugs,homepage:homepage,scripts:scripts,devDependencies:devDependencies,dependencies:dependencies};
+const name="@cuenca-mx/cuenca-js";const version="2.0.0-dev1";const description="Cuenca client for JS";const main="./build/index.cjs";const module$1="./build/index.mjs";const browser="./build/umd/cuenca.umd.js";const types="./build/dts/index.d.ts";const sideEffects=false;const files=["build/**/*","errors/**/*","jwt/**/*","requests/**/*","types/**/*"];const exports$1={".":{types:"./build/dts/index.d.ts","import":"./build/index.mjs",require:"./build/index.cjs"},"./errors":{types:"./build/dts/errors.d.ts","import":"./build/errors/index.mjs",require:"./build/errors/index.cjs"},"./jwt":{types:"./build/dts/jwt.d.ts","import":"./build/jwt/index.mjs",require:"./build/jwt/index.cjs"},"./requests":{types:"./build/dts/requests/index.d.ts","import":"./build/requests/index.mjs",require:"./build/requests/index.cjs"},"./types":{types:"./build/dts/types/index.d.ts","import":"./build/types/index.mjs",require:"./build/types/index.cjs"}};const packageManager="yarn@3.2.0";const type="module";const repository={type:"git",url:"https://github.com/cuenca-mx/cuenca-js.git",directory:"packages/cuenca-js"};const keywords=["cuenca"];const license="MIT";const bugs={url:"https://github.com/cuenca-mx/cuenca-js/issues"};const homepage="https://cuenca.com";const engines={node:">=20"};const scripts={build:"rm -rf build/ tsconfig.tsbuildinfo && yarn rollup --config && yarn tsc -p tsconfig.json && yarn tsc-alias -p tsconfig.json --outDir build/dts",test:"vitest run --coverage",publish:"yarn build && yarn npm publish",dev:"rm -rf build/ && yarn rollup --config && yarn node ../example.cjs",example:"yarn node ../example.cjs"};const devDependencies={"@rollup/plugin-json":"^4.1.0","@rollup/plugin-node-resolve":"^13.1.1","@rollup/plugin-typescript":"^11.1.6","@vitest/coverage-v8":"^1.6.0",rollup:"^2.61.1","rollup-plugin-terser":"^7.0.2","tsc-alias":"^1.8.10",typescript:"^4.9.5","vite-tsconfig-paths":"^4.3.2",vitest:"^1.6.0"};const dependencies={buffer:"^6.0.3"};var pkg = {name:name,version:version,description:description,main:main,module:module$1,browser:browser,types:types,sideEffects:sideEffects,files:files,exports:exports$1,packageManager:packageManager,type:type,repository:repository,keywords:keywords,license:license,bugs:bugs,homepage:homepage,engines:engines,scripts:scripts,devDependencies:devDependencies,dependencies:dependencies};
+
+/* global FormData */
+
+const DEFAULT_TIMEOUT_MS = 45000;
+
+const cloneAndSerializeDates = (value) => {
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(cloneAndSerializeDates);
+  if (
+    value !== null &&
+    typeof value === 'object' &&
+    value.constructor === Object
+  ) {
+    const out = {};
+    Object.keys(value).forEach((key) => {
+      out[key] = cloneAndSerializeDates(value[key]);
+    });
+    return out;
+  }
+  return value;
+};
+
+function buildUrl(baseURL, url, params) {
+  const target = new URL(url, baseURL);
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value === null || value === undefined) return;
+      target.searchParams.append(key, value);
+    });
+  }
+  return target.toString();
+}
+
+async function parseBody(response, responseType) {
+  if (responseType === 'arraybuffer') return response.arrayBuffer();
+  if (responseType === 'blob') return response.blob();
+  const contentType = response.headers.get('content-type') || '';
+  if (contentType.includes('application/json')) {
+    const text = await response.text();
+    return text ? JSON.parse(text) : {};
+  }
+  if (
+    contentType.includes('application/pdf') ||
+    contentType.includes('application/octet-stream')
+  ) {
+    return response.arrayBuffer();
+  }
+  return response.text();
+}
+
+async function fetchTransport({
+  baseURL,
+  url,
+  method = 'GET',
+  headers = {},
+  params,
+  data,
+  responseType,
+  timeout = DEFAULT_TIMEOUT_MS,
+  signal: externalSignal,
+}) {
+  const fullUrl = buildUrl(baseURL, url, params);
+  const outgoingHeaders = { ...headers };
+
+  let body;
+  if (data !== null && data !== undefined) {
+    if (typeof FormData !== 'undefined' && data instanceof FormData) {
+      body = data;
+      Object.keys(outgoingHeaders)
+        .filter((key) => key.toLowerCase() === 'content-type')
+        .forEach((key) => delete outgoingHeaders[key]);
+    } else if (typeof data === 'string' || data instanceof ArrayBuffer) {
+      body = data;
+    } else {
+      body = JSON.stringify(data);
+    }
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  if (externalSignal) {
+    if (externalSignal.aborted) controller.abort();
+    else
+      externalSignal.addEventListener('abort', () => controller.abort(), {
+        once: true,
+      });
+  }
+
+  let response;
+  try {
+    response = await fetch(fullUrl, {
+      method,
+      headers: outgoingHeaders,
+      body,
+      signal: controller.signal,
+    });
+  } catch (error) {
+    const err = new Error(error.message || 'Network error');
+    err.request = {};
+    err.errno = error.errno ?? error.cause?.errno;
+    err.code =
+      error.code ??
+      error.cause?.code ??
+      (error.name === 'AbortError' ? 'ETIMEDOUT' : undefined);
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!response.ok) {
+    let errorData;
+    try {
+      errorData = await parseBody(response, responseType);
+    } catch (parseErr) {
+      errorData = await response.text().catch(() => null);
+    }
+    const err = new Error(`HTTP ${response.status}`);
+    err.response = {
+      data: errorData,
+      status: response.status,
+      headers: response.headers,
+    };
+    throw err;
+  }
+
+  const responseData = await parseBody(response, responseType);
+  return {
+    data: responseData,
+    status: response.status,
+    headers: response.headers,
+  };
+}
 
 class Client {
   constructor({
@@ -38,10 +168,10 @@ class Client {
     this.phase = phase;
     this.basicAuth = { apiKey, apiSecret };
     this.jwtToken = null;
-    this._session = axios__default["default"].create({
-      headers: { 'Accept-Language': language },
-      timeout: 45000,
-    });
+    this._defaultHeaders = { 'Accept-Language': language };
+    this._sessionHeaders = {};
+    this._timeout = DEFAULT_TIMEOUT_MS;
+    this._session = { request: (config) => fetchTransport(config) };
   }
 
   get session() {
@@ -49,9 +179,16 @@ class Client {
   }
 
   get origin() {
-    return this.phase === data.Phase.Api
-      ? 'https://api.cuenca.com'
-      : `https://api.${this.phase.value}.cuenca.com`;
+    const hostByPhase = {
+      [data.Phase.Sandbox]: 'sandbox.cuenca.com',
+      [data.Phase.Stage]: 'api.stage.cuenca.com',
+      [data.Phase.Api]: 'api.cuenca.com',
+    };
+    const host = hostByPhase[this.phase];
+    if (!host) {
+      throw new errors_index.CuencaException(`Unsupported phase: ${this.phase}`);
+    }
+    return `https://${host}`;
   }
 
   get authHeader() {
@@ -64,44 +201,37 @@ class Client {
   }
 
   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;
+    const previous = {};
+    Object.keys(obj).forEach((key) => {
+      previous[key] = Object.prototype.hasOwnProperty.call(
+        this._sessionHeaders,
+        key,
+      )
+        ? this._sessionHeaders[key]
+        : undefined;
+      this._sessionHeaders[key] = obj[key];
     });
     return {
-      interceptorId,
-      eject: () => this._session.interceptors.request.eject(interceptorId),
+      eject: () => {
+        Object.keys(previous).forEach((key) => {
+          if (previous[key] === undefined) delete this._sessionHeaders[key];
+          else this._sessionHeaders[key] = previous[key];
+        });
+      },
     };
   }
 
   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;
-    });
+    const hadPrevious = Object.prototype.hasOwnProperty.call(
+      this._sessionHeaders,
+      header,
+    );
+    const previous = hadPrevious ? this._sessionHeaders[header] : undefined;
+    delete this._sessionHeaders[header];
     return {
-      interceptorId,
-      eject: () => this._session.interceptors.request.eject(interceptorId),
+      eject: () => {
+        if (hadPrevious) this._sessionHeaders[header] = previous;
+      },
     };
   }
 
@@ -131,20 +261,27 @@ class Client {
     }
   }
 
-  async get({ endpoint, format, params }) {
-    return this.request({ endpoint, format, params });
+  async get({ endpoint, format, params, headers, responseType }) {
+    return this.request({ endpoint, format, params, headers, responseType });
   }
 
-  async post({ endpoint, data, multipart }) {
-    return this.request({ method: 'POST', endpoint, data, multipart });
+  async post({ endpoint, data, multipart, headers, responseType }) {
+    return this.request({
+      method: 'POST',
+      endpoint,
+      data,
+      multipart,
+      headers,
+      responseType,
+    });
   }
 
-  async patch({ endpoint, data }) {
-    return this.request({ method: 'PATCH', endpoint, data });
+  async patch({ endpoint, data, headers }) {
+    return this.request({ method: 'PATCH', endpoint, data, headers });
   }
 
-  async delete({ endpoint, data }) {
-    return this.request({ method: 'DELETE', endpoint, data });
+  async delete({ endpoint, data, headers }) {
+    return this.request({ method: 'DELETE', endpoint, data, headers });
   }
 
   async request({
@@ -154,14 +291,21 @@ class Client {
     method = 'GET',
     multipart = false,
     params = null,
+    headers: extraHeaders = null,
+    responseType,
+    timeout,
+    signal,
   }) {
-    let headers = {};
+    if (this.jwtToken && this.jwtToken.isExpired) {
+      this.jwtToken = await jwt_index.Jwt.create(this);
+    }
+
+    const headers = { ...this._defaultHeaders, ...this._sessionHeaders };
 
     if (!multipart) {
-      headers = {
-        'Content-Type': 'application/json',
-        Accept: format.value,
-      };
+      headers['Content-Type'] = 'application/json';
+      // FileFormat is a string union (ADR #61 / enums #62) — not `{ value }`.
+      headers.Accept = format;
     }
 
     if (this.authHeader) {
@@ -177,32 +321,29 @@ class Client {
     }
 
     if (this.jwtToken) {
-      if (this.jwtToken.isExpired) {
-        this.jwtToken = await jwt_index.Jwt.create(this);
-      }
       headers['X-Cuenca-Token'] = this.jwtToken.token;
     }
-    const headersInterceptor = this.addHeadersToRequest(headers);
 
-    const modifiedData = data$1;
+    if (extraHeaders) Object.assign(headers, extraHeaders);
+
+    let modifiedData = data$1;
     if (modifiedData && !multipart) {
-      Object.keys(modifiedData).forEach((k) => {
-        if (modifiedData[k] instanceof Date) {
-          modifiedData[k] = modifiedData[k].toISOString();
-        }
-      });
+      modifiedData = cloneAndSerializeDates(data$1);
     }
 
-    const configInterceptor = this.addConfigToRequest({
-      method,
-      params,
-      data: modifiedData,
-      url: endpoint,
-    });
-
-    let response;
     try {
-      response = await this._session.request({ baseURL: this.origin });
+      const response = await this._session.request({
+        baseURL: this.origin,
+        url: endpoint,
+        method,
+        headers,
+        params,
+        data: modifiedData,
+        responseType,
+        timeout: timeout ?? this._timeout,
+        signal,
+      });
+      return response.data;
     } catch (error) {
       if (error.response) {
         throw new errors_index.CuencaResponseException(
@@ -210,2940 +351,1287 @@ class Client {
           error.response.status,
         );
       } else if (error.request) {
-        throw new errors_index.CuencaException(
-          `No response received: ${error.errno}: ${error.code}`,
-        );
+        const code = error.code ?? error.name ?? 'ENETWORK';
+        const errno = error.errno ?? 'unknown';
+        throw new errors_index.CuencaException(`No response received: ${errno}: ${code}`);
       } else {
         throw new errors_index.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 = data.dateToUTC(createdAt);
-    this.id = id;
-    this.institutionName = institutionName;
-    this.name = name;
-    this.userId = userId;
-  }
+const Account = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  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,
-    });
-}
+const Alert = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        const changeLog = obj.change_log;
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            changeLog: changeLog && Array.isArray(changeLog) && changeLog.length > 0
+                ? changeLog.map(vulnerableActivity.AlertLog.fromObject)
+                : undefined,
+        }, ['createdAt', 'updatedAt', 'transactionDate', 'committeeMeetingDate']);
+    },
+};
 
-class Alert {
-  constructor({
-    agent,
-    accountNumber,
-    actualPeriodCount,
-    actualPeriodSum,
-    aggregationType,
-    changeLog,
-    comments,
-    committeeMeetingDate,
-    createdAt,
-    questionnaireId,
-    description,
-    hasQuestionnaire,
-    id,
-    institutionName,
-    level,
-    name,
-    period,
-    periodNumber,
-    status,
-    sourceType,
-    transactionDate,
-    type,
-    typeOfFilter,
-    userId,
-    updatedAt,
-  }) {
-    this.accountNumber = accountNumber;
-    this.actualPeriodCount = actualPeriodCount;
-    this.actualPeriodSum = actualPeriodSum;
-    this.agent = agent;
-    this.aggregationType = aggregationType;
-    this.comments = comments;
-    this.committeeMeetingDate = data.dateToUTC(committeeMeetingDate);
-    this.createdAt = data.dateToUTC(createdAt);
-    this.questionnaireId = questionnaireId;
-    this.description = description;
-    this.hasQuestionnaire = hasQuestionnaire;
-    this.id = id;
-    this.institutionName = institutionName;
-    this.level = data.enumValueFromString(data.MLIndicatorLevel, level);
-    this.name = name;
-    this.period = data.enumValueFromString(data.MLIndicatorPeriod, period);
-    this.periodNumber = periodNumber;
-    this.status = data.enumValueFromString(data.AlertStatus, status);
-    this.sourceType = data.enumValueFromString(data.SourceAlertType, sourceType);
-    this.transactionDate = data.dateToUTC(transactionDate);
-    this.type = data.enumValueFromString(data.MLIndicatorType, type);
-    this.typeOfFilter = data.enumValueFromString(data.PLDFilterType, typeOfFilter);
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.userId = userId;
-    this.changeLog = changeLog;
-  }
+const ApiKey = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'deactivatedAt',
+        'updatedAt',
+    ]),
+    isActive: (apiKey) => {
+        const todayUTC = data.dateToUTC(Date.now());
+        return (!apiKey.deactivatedAt ||
+            apiKey.deactivatedAt.getTime() > todayUTC.getTime());
+    },
+};
 
-  static fromObject = ({
-    agent,
-    comments,
-    description,
-    id,
-    level,
-    name,
-    period,
-    status,
-    type,
-    ...obj
-  }) =>
-    new Alert({
-      agent,
-      comments,
-      description,
-      id,
-      level,
-      name,
-      period,
-      status,
-      type,
-      accountNumber: obj.account_number,
-      actualPeriodCount: obj.actual_period_count,
-      actualPeriodSum: obj.actual_period_sum,
-      aggregationType: obj.aggregation_type,
-      changeLog: obj.change_log,
-      committeeMeetingDate: obj.committee_meeting_date,
-      createdAt: obj.created_at,
-      questionnaireId: obj.questionnaire_id,
-      hasQuestionnaire: obj.has_questionnaire,
-      institutionName: obj.institution_name,
-      periodNumber: obj.period_number,
-      sourceType: obj.source_type,
-      transactionDate: obj.transaction_date,
-      typeOfFilter: obj.type_of_filter,
-      updatedAt: obj.updated_at,
-      userId: obj.user_id,
-    });
+const Arpc = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), ['createdAt']),
+};
 
-  get changeLog() {
-    return this._changeLog;
-  }
+const BalanceEntry = {
+    // The wire calls this field `type`; the model calls it `entryType`.
+    fromObject: (obj) => {
+        const { type, ...rest } = obj;
+        const camelized = data.camelize(rest);
+        return data.coerceDatesWithDefaults({ ...camelized, entryType: type }, [
+            'createdAt',
+        ]);
+    },
+};
 
-  set changeLog(value) {
-    if (!value || !Array.isArray(value) || value.length === 0) return;
-    this._changeLog = value.map((entry) => vulnerableActivity.AlertLog.fromObject(entry));
-  }
-}
+const BillPayment = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-class ApiKey {
-  constructor({ createdAt, deactivatedAt, id, secret, userId, updatedAt }) {
-    this.createdAt = data.dateToUTC(createdAt);
-    this.deactivatedAt = data.dateToUTC(deactivatedAt);
-    this.id = id;
-    this.secret = secret;
-    this.userId = userId;
-    this.updatedAt = data.dateToUTC(updatedAt);
-  }
+// Empty objects (`{}`) are treated the same as absent — mirrors the old
+// setters' `Object.keys(value).length === 0` guard.
+const nonEmpty = (value) => value && typeof value === 'object' && Object.keys(value).length > 0
+    ? value
+    : undefined;
+const BridgeAccount = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        const address = nonEmpty(obj.address);
+        const govtId = nonEmpty(obj.govt_id);
+        const proofOfAddress = nonEmpty(obj.proof_of_address);
+        const termsOfService = nonEmpty(obj.terms_of_service);
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            address: address ? vulnerableActivity.Address.fromObject(address) : undefined,
+            govtId: govtId ? vulnerableActivity.KYCFile.fromObject(govtId) : undefined,
+            proofOfAddress: proofOfAddress
+                ? vulnerableActivity.KYCFile.fromObject(proofOfAddress)
+                : undefined,
+            termsOfService: termsOfService
+                ? vulnerableActivity.TOSAgreements.fromObject(termsOfService)
+                : undefined,
+        }, ['createdAt', '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,
-    });
+const BridgeBankAccount = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  get isActive() {
-    const todayUTC = data.dateToUTC(Date.now());
-    return (
-      !this.deactivatedAt || this.deactivatedAt.getTime() > todayUTC.getTime()
-    );
-  }
-}
+const BridgeClabe = {
+    // `account` is derived from `account_uri` (`/accounts/AC01` -> `AC01`),
+    // not a straight rename.
+    fromObject: (obj) => {
+        const { account_uri: accountUri, ...rest } = obj;
+        const camelized = data.camelize(rest);
+        return {
+            ...camelized,
+            account: typeof accountUri === 'string' ? accountUri.split('/')[2] : undefined,
+        };
+    },
+};
 
-class Arpc {
-  constructor({ arpc, createdAt, cardUri, isValidArqc }) {
-    this.arpc = arpc;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.cardUri = cardUri;
-    this.isValidArqc = isValidArqc;
-  }
+const BridgeTransaction = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  static fromObject = ({ arpc, ...obj }) =>
-    new Arpc({
-      arpc,
-      createdAt: obj.created_at,
-      cardUri: obj.card_uri,
-      isValidArqc: obj.is_valid_arqc,
-    });
-}
+const Card = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-class BalanceEntry {
-  constructor({
-    amount,
-    createdAt,
-    descriptor,
-    entryType,
-    fundingInstrumentUri,
-    id,
-    name,
-    relatedTransactionUri,
-    rollingBalance,
-  }) {
-    this.amount = amount;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.descriptor = descriptor;
-    this.entryType = data.enumValueFromString(data.EntryType, entryType);
-    this.fundingInstrumentUri = fundingInstrumentUri;
-    this.id = id;
-    this.name = name;
-    this.relatedTransactionUri = relatedTransactionUri;
-    this.rollingBalance = rollingBalance;
-  }
+const CardActivation = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  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,
-    });
-}
+const CardTransaction = {
+    // Three wire keys don't follow the usual snake_case rename:
+    // `error_type` -> cardErrorType, `card_last4` -> cardLastFour,
+    // `related_card_transaction` -> relatedCardTransactionsUris. `metadata`
+    // is opaque passthrough data and must not be recursively camelized.
+    fromObject: (obj) => {
+        const { error_type: cardErrorType, card_last4: cardLastFour, related_card_transaction: relatedCardTransactionsUris, metadata, ...rest } = obj;
+        const camelized = data.camelize(rest);
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            cardErrorType,
+            cardLastFour,
+            relatedCardTransactionsUris,
+            metadata,
+        }, ['createdAt']);
+    },
+};
 
-class Transaction {
-  constructor({ amount, createdAt, descriptor, status, userId }) {
-    this.amount = amount;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.descriptor = descriptor;
-    this.status = data.enumValueFromString(data.TransactionStatus, status);
-    this.userId = userId;
-  }
-}
+const CardValidation = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+    isActive: (validation) => validation.cardStatus === data.CardStatus.Active,
+};
 
-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;
-  }
+const Commission = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  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,
-    });
-}
+const Deposit = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-class BridgeAccount {
-  constructor({
-    id,
-    createdAt,
-    updatedAt,
-    names,
-    firstSurname,
-    secondSurname,
-    dateOfBirth,
-    countryOfBirth,
-    rfc,
-    curp,
-    userId,
-    gender,
-    phoneNumber,
-    emailAddress,
-    clientClabe,
-    govtId,
-    proofOfAddress,
-    status,
-    termsOfService,
-    address,
-  }) {
-    this.id = id;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.emailAddress = emailAddress;
-    this.clientClabe = clientClabe;
-    this.govtId = govtId;
-    this.names = names;
-    this.firstSurname = firstSurname;
-    this.secondSurname = secondSurname;
-    this.dateOfBirth = dateOfBirth;
-    this.countryOfBirth = countryOfBirth;
-    this.rfc = rfc;
-    this.curp = curp;
-    this.userId = userId;
-    this.gender = gender;
-    this.phoneNumber = phoneNumber;
-    this.proofOfAddress = proofOfAddress;
-    this.status = data.enumValueFromString(data.BridgeAccountStatus, status);
-    this.termsOfService = termsOfService;
-    this.address = address;
-  }
+const File = {
+    fromObject: (obj) => data.camelize(obj),
+};
 
-  static fromObject = ({ status, address, ...obj }) =>
-    new BridgeAccount({
-      address,
-      status,
-      id: obj.id,
-      createdAt: obj.created_at,
-      updatedAt: obj.updated_at,
-      clientClabe: obj.client_clabe,
-      names: obj.names,
-      firstSurname: obj.first_surname,
-      secondSurname: obj.second_surname,
-      dateOfBirth: obj.date_of_birth,
-      countryOfBirth: obj.country_of_birth,
-      rfc: obj.rfc,
-      curp: obj.curp,
-      userId: obj.user_id,
-      gender: obj.gender,
-      govtId: obj.govt_id,
-      emailAddress: obj.email_address,
-      phoneNumber: obj.phone_number,
-      proofOfAddress: obj.proof_of_address,
-      termsOfService: obj.terms_of_service,
-    });
+const FraudFundsTransfer = {
+    fromObject: (obj) => data.camelize(obj),
+};
 
-  get address() {
-    return this._address;
-  }
+const KYCValidations = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        return data.coerceDatesWithDefaults({ ...camelized, filesUri: camelized.filesUri || [] }, ['createdAt', 'updatedAt', 'deactivatedAt']);
+    },
+};
 
-  set address(value) {
-    if (!value || Object.keys(value).length === 0) return;
-    this._address = vulnerableActivity.Address.fromObject(value);
-  }
+const BaseUser = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            address: obj.address
+                ? vulnerableActivity.Address.fromObject(obj.address)
+                : undefined,
+        }, ['createdAt', 'updatedAt']);
+    },
+};
 
-  get proofOfAddress() {
-    return this._proofOfAddress;
-  }
+const LegalPerson = {
+    fromObject: (obj) => {
+        const base = BaseUser.fromObject(obj);
+        const camelized = data.camelize(obj);
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            ...base,
+            legalRepresentatives: obj.legal_representatives
+                ? obj.legal_representatives.map(vulnerableActivity.LegalRepresentatives.fromObject)
+                : undefined,
+        }, ['createdAt', 'updatedAt']);
+    },
+};
 
-  set proofOfAddress(value) {
-    if (!value || Object.keys(value).length === 0) return;
-    this._proofOfAddress = vulnerableActivity.KYCFile.fromObject(value);
-  }
+const LoginToken = {
+    fromObject: (obj) => ({
+        id: obj.id,
+    }),
+};
 
-  get govtId() {
-    return this._govtId;
-  }
+const Operator = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-  set govtId(value) {
-    if (!value || Object.keys(value).length === 0) return;
-    this._govtId = vulnerableActivity.KYCFile.fromObject(value);
-  }
+const OperatorLogin = {
+    fromObject: (obj) => data.camelize(obj),
+};
 
-  get termsOfService() {
-    return this._termsOfService;
-  }
+const TransactionalProfile = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        return {
+            ...camelized,
+            deposits: obj.deposits
+                ? vulnerableActivity.TransactionalProfileServices.fromObject(obj.deposits)
+                : undefined,
+            withdrawal: obj.withdrawal
+                ? vulnerableActivity.TransactionalProfileServices.fromObject(obj.withdrawal)
+                : undefined,
+        };
+    },
+};
 
-  set termsOfService(value) {
-    if (!value || Object.keys(value).length === 0) return;
-    this._termsOfService = vulnerableActivity.TOSAgreements.fromObject(value);
-  }
-}
+const toLegalRepresentatives = (obj) => {
+    const value = obj.legal_representatives;
+    return value ? value.map(vulnerableActivity.LegalRepresentatives.fromObject) : undefined;
+};
+const toTransactionalProfile = (obj) => {
+    const value = obj.transactional_profile;
+    return value ? TransactionalProfile.fromObject(value) : undefined;
+};
+const Partner = {
+    fromObject: (obj) => {
+        const base = BaseUser.fromObject(obj);
+        const camelized = data.camelize(obj);
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            ...base,
+            audit: obj.audit
+                ? vulnerableActivity.Audit.fromObject(obj.audit)
+                : undefined,
+            businessDetails: obj.business_details
+                ? vulnerableActivity.BusinessDetails.fromObject(obj.business_details)
+                : undefined,
+            externalAccount: obj.external_account
+                ? vulnerableActivity.ExternalAccount.fromObject(obj.external_account)
+                : undefined,
+            license: obj.license
+                ? vulnerableActivity.License.fromObject(obj.license)
+                : undefined,
+            shareholders: obj.shareholders
+                ? obj.shareholders.map(vulnerableActivity.ShareholderMoral.fromObject)
+                : undefined,
+            legalRepresentatives: toLegalRepresentatives(obj),
+            transactionalProfile: toTransactionalProfile(obj),
+            vulnerableActivity: obj.vulnerable_activity
+                ? vulnerableActivity.VulnerableActivity.fromObject(obj.vulnerable_activity)
+                : undefined,
+        }, ['incorporationDate']);
+    },
+};
 
-class BridgeBankAccount {
-  constructor({
-    clabe,
-    createdAt,
-    curp,
-    error,
-    firstName,
-    id,
-    names,
-    rfc,
-    secondSurname,
-    status,
-  }) {
-    this.clabe = clabe;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.curp = curp;
-    this.error = error;
-    this.firstName = firstName;
-    this.id = id;
-    this.names = names;
-    this.rfc = rfc;
-    this.secondSurname = secondSurname;
-    this.status = data.enumValueFromString(data.BridgeBankAccountStatus, status);
-  }
+const PostalCode = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-  static fromObject = ({
-    clabe,
-    curp,
-    error,
-    id,
-    names,
-    rfc,
-    status,
-    ...obj
-  }) =>
-    new BridgeBankAccount({
-      clabe,
-      curp,
-      error,
-      id,
-      names,
-      rfc,
-      status,
-      createdAt: obj.created_at,
-      firstName: obj.first_name,
-      secondSurname: obj.second_surname,
-    });
-}
+const Saving = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'deactivatedAt',
+        'goalDate',
+        'updatedAt',
+    ]),
+};
 
-class BridgeClabe {
-  constructor({ account, clabe, currency, id, network, platformId }) {
-    this.account = account;
-    this.clabe = clabe;
-    this.currency = data.enumValueFromString(data.Currency, currency);
-    this.id = id;
-    this.network = data.enumValueFromString(data.Network, network);
-    this.platformId = platformId;
-  }
+const ServiceProvider = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        return {
+            ...camelized,
+            categories: camelized.categories == null ? [] : camelized.categories,
+        };
+    },
+};
 
-  static fromObject = ({ clabe, currency, id, network, ...obj }) =>
-    new BridgeClabe({
-      clabe,
-      currency,
-      id,
-      network,
-      account: obj.account_uri.split('/')[2],
-      platformId: obj.platform_id,
-    });
-}
+const Session = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'expiresAt',
+    ]),
+};
 
-class BridgeTransaction {
-  constructor({
-    id,
-    createdAt,
-    platformId,
-    type,
-    status,
-    accountUri,
-    quoteUri,
-    currency,
-    network,
-    sourceWallet,
-    destinationWallet,
-    bankAccountUri,
-    cuencaId,
-    cuentaOrdenante,
-    cuentaBeneficiario,
-    nombreOrdenante,
-    claveRastreo,
-    rfcCurpOrdenante,
-    concepto,
-    referenciaNumerica,
-    signature,
-    trackingLink,
-    fromCurrency,
-    toCurrency,
-    fromAmount,
-    toAmount,
-  }) {
-    this.id = id;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.platformId = platformId;
-    this.type = data.enumValueFromString(data.BridgeTransactionType, type);
-    this.status = data.enumValueFromString(data.TransactionStatus, status);
-    this.accountUri = accountUri;
-    this.quoteUri = quoteUri;
-    this.currency = data.enumValueFromString(data.Currency, currency);
-    this.network = data.enumValueFromString(data.Network, network);
-    this.sourceWallet = sourceWallet;
-    this.destinationWallet = destinationWallet;
-    this.bankAccountUri = bankAccountUri;
-    this.cuencaId = cuencaId;
-    this.cuentaOrdenante = cuentaOrdenante;
-    this.cuentaBeneficiario = cuentaBeneficiario;
-    this.nombreOrdenante = nombreOrdenante;
-    this.claveRastreo = claveRastreo;
-    this.rfcCurpOrdenante = rfcCurpOrdenante;
-    this.concepto = concepto;
-    this.referenciaNumerica = referenciaNumerica;
-    this.signature = signature;
-    this.trackingLink = trackingLink;
-    this.fromCurrency = data.enumValueFromString(data.Currency, fromCurrency);
-    this.toCurrency = data.enumValueFromString(data.Currency, toCurrency);
-    this.fromAmount = fromAmount;
-    this.toAmount = toAmount;
-  }
+const Statement = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  static fromObject = ({
-    type,
-    status,
-    currency,
-    network,
-    concepto,
-    signature,
-    ...obj
-  }) =>
-    new BridgeTransaction({
-      id: obj.id,
-      createdAt: obj.created_at,
-      platformId: obj.platform_id,
-      accountUri: obj.account_uri,
-      quoteUri: obj.quote_uri,
-      sourceWallet: obj.source_wallet,
-      destinationWallet: obj.destination_wallet,
-      bankAccountUri: obj.bank_account_uri,
-      cuencaId: obj.cuenca_id,
-      cuentaOrdenante: obj.cuenta_ordenante,
-      cuentaBeneficiario: obj.cuenta_beneficiario,
-      nombreOrdenante: obj.nombre_ordenante,
-      claveRastreo: obj.clave_rastreo,
-      rfcCurpOrdenante: obj.rfc_curp_ordenante,
-      referenciaNumerica: obj.referencia_numerica,
-      trackingLink: obj.tracking_link,
-      fromCurrency: obj.from_currency,
-      toCurrency: obj.to_currency,
-      fromAmount: obj.from_amount,
-      toAmount: obj.to_amount,
-      type,
-      status,
-      currency,
-      network,
-      concepto,
-      signature,
-    });
-}
+const Transfer = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-class Card {
-  constructor({
-    createdAt,
-    cvv2,
-    expMonth,
-    expYear,
-    fundingType,
-    id,
-    issuer,
-    number,
-    pin,
-    status,
-    type,
-    updatedAt,
-    userId,
-  }) {
-    this.createdAt = data.dateToUTC(createdAt);
-    this.cvv2 = cvv2;
-    this.expMonth = expMonth;
-    this.expYear = expYear;
-    this.fundingType = data.enumValueFromString(data.CardFundingType, fundingType);
-    this.id = id;
-    this.issuer = data.enumValueFromString(data.CardIssuer, issuer);
-    this.number = number;
-    this.pin = pin;
-    this.status = data.enumValueFromString(data.CardStatus, status);
-    this.type = data.enumValueFromString(data.CardType, type);
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.userId = userId;
-  }
+const wrapKycFile = (value) => value ? vulnerableActivity.KYCFile.fromObject(value) : undefined;
+const User = {
+    fromObject: (obj) => {
+        const camelized = data.camelize(obj);
+        return data.coerceDatesWithDefaults({
+            ...camelized,
+            address: obj.address
+                ? vulnerableActivity.Address.fromObject(obj.address)
+                : undefined,
+            govtId: wrapKycFile(obj.govt_id),
+            proofOfAddress: wrapKycFile(obj.proof_of_address),
+            proofOfLife: wrapKycFile(obj.proof_of_life),
+            curpDocument: wrapKycFile(obj.curp_document),
+            termsOfService: obj.terms_of_service
+                ? vulnerableActivity.TOSAgreements.fromObject(obj.terms_of_service)
+                : undefined,
+        }, ['createdAt', 'updatedAt']);
+    },
+};
 
-  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,
-    });
-}
+const UserCredential = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-class CardActivation {
-  constructor({ cardUri, createdAt, id, ipAddress, success, userId }) {
-    this.cardUri = cardUri;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.id = id;
-    this.ipAddress = ipAddress;
-    this.success = success;
-    this.userId = userId;
-  }
+const UserLogin = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'lastLoginAt',
+    ]),
+};
 
-  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,
-    });
-}
+const UserReport = {
+    fromObject: (obj) => data.camelize(obj),
+};
 
-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 = data.enumValueFromString(data.CardErrorType, cardErrorType);
-    this.cardLastFour = cardLastFour;
-    this.cardType = data.enumValueFromString(data.CardType, cardType);
-    this.cardUri = cardUri;
-    this.metadata = metadata;
-    this.network = network;
-    this.relatedCardTransactionsUris = relatedCardTransactionsUris;
-    this.type = data.enumValueFromString(data.CardTransactionType, type);
-  }
+const UserTosAgreement = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-  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,
-    });
-}
+const Verification = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'updatedAt',
+    ]),
+};
 
-class CardValidation {
-  constructor({
-    cardStatus,
-    cardType,
-    cardUri,
-    createdAt,
-    isExpired,
-    isPinAttemptsExceeded,
-    isValidCvv,
-    isValidCvv2,
-    isValidExpDate,
-    isValidIcvv,
-    isValidPinBlock,
-    userId,
-  }) {
-    this.cardStatus = data.enumValueFromString(data.CardStatus, cardStatus);
-    this.cardType = data.enumValueFromString(data.CardType, cardType);
-    this.cardUri = cardUri;
-    this.createdAt = data.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;
-  }
+const WalletTransaction = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+    ]),
+};
 
-  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,
-    });
+const WhatsAppTransfer = {
+    fromObject: (obj) => data.coerceDatesWithDefaults(data.camelize(obj), [
+        'createdAt',
+        'expiresAt',
+        'updatedAt',
+    ]),
+};
 
-  get isActive() {
-    return this.cardStatus === data.CardStatus.Active;
-  }
+const encodeCursor = (uri) => Buffer.Buffer.from(uri, 'utf8').toString('base64url');
+const decodeCursor = (cursor) => Buffer.Buffer.from(cursor, 'base64url').toString('utf8');
+class Resource {
+    constructor(client, path, fromObject) {
+        this.client = client;
+        this.path = path;
+        this.fromObject = fromObject;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toParams(query) {
+        return vulnerableActivity.toParams(query);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toQueryString(query) {
+        return vulnerableActivity.toQueryString(query);
+    }
 }
-
-class Commission extends Transaction {
-  constructor({
-    amount,
-    createdAt,
-    descriptor,
-    relatedTransactionUri,
-    status,
-    type,
-    userId,
-  }) {
-    super({
-      amount,
-      createdAt,
-      descriptor,
-      status,
-      userId,
-    });
-    this.relatedTransactionUri = relatedTransactionUri;
-    this.type = data.enumValueFromString(data.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,
-    });
+function Retrievable(Base) {
+    return class extends Base {
+        async retrieve(id) {
+            const response = await this.client.get({
+                endpoint: `/${this.path}/${id}`,
+            });
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(response);
+        }
+    };
 }
-
-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 = data.enumValueFromString(data.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,
-    });
+function Creatable(Base) {
+    return class extends Base {
+        async _create(data) {
+            const response = await this.client.post({
+                endpoint: `/${this.path}`,
+                data,
+            });
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(response);
+        }
+    };
+}
+function Updateable(Base) {
+    return class extends Base {
+        async _update(id, data) {
+            const response = await this.client.patch({
+                endpoint: `/${this.path}/${id}`,
+                data,
+            });
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(response);
+        }
+    };
+}
+function Uploadable(Base) {
+    return class extends Base {
+        async _upload(data) {
+            const response = await this.client.post({
+                endpoint: `/${this.path}`,
+                data,
+                multipart: true,
+            });
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(response);
+        }
+    };
+}
+function Deactivable(Base) {
+    return class extends Base {
+        async _deactivate(id, data = {}) {
+            const response = await this.client.delete({
+                endpoint: `/${this.path}/${id}`,
+                data,
+            });
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(response);
+        }
+    };
+}
+function Downlodable(Base) {
+    return class extends Base {
+        async _download(id, format, responseType) {
+            const config = { endpoint: `/${this.path}/${id}` };
+            if (format !== undefined)
+                config.format = format;
+            if (responseType !== undefined)
+                config.responseType = responseType;
+            return this.client.get(config);
+        }
+    };
+}
+const MAX_PAGES = 10000;
+function Queryable(Base) {
+    return class extends Base {
+        async one(query = {}) {
+            const { items } = (await this.client.get({
+                endpoint: `/${this.path}`,
+                // TODO(cuenca-js#64-followup): tighten generic bound to preserve Q through toParams — currently downcast to QueryParams.
+                params: this.toParams({
+                    ...query,
+                    limit: 2,
+                }),
+            }));
+            if (!items || items.length === 0)
+                throw new errors_index.NoResultFound();
+            if (items.length > 1)
+                throw new errors_index.MultipleResultsFound();
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(items[0]);
+        }
+        async first(query = {}) {
+            const { items } = (await this.client.get({
+                endpoint: `/${this.path}`,
+                // TODO(cuenca-js#64-followup): tighten generic bound to preserve Q through toParams — currently downcast to QueryParams.
+                params: this.toParams({
+                    ...query,
+                    limit: 1,
+                }),
+            }));
+            if (!items || items.length === 0)
+                return null;
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            return this.fromObject(items[0]);
+        }
+        async count(query = {}) {
+            const params = {
+                // TODO(cuenca-js#64-followup): tighten generic bound to preserve Q through toParams — currently downcast to QueryParams.
+                ...this.toParams(query),
+                count: 1,
+            };
+            const { count } = (await this.client.get({
+                endpoint: `/${this.path}`,
+                params,
+            }));
+            return count ?? 0;
+        }
+        async page(query, cursor) {
+            // TODO(cuenca-js#64-followup): tighten generic bound to preserve Q through toQueryString — currently downcast to QueryParams.
+            const actualQuery = (query ?? {});
+            const normalized = cursor && cursor.length > 0 ? decodeCursor(cursor) : null;
+            const endpoint = normalized ?? `/${this.path}?${this.toQueryString(actualQuery)}`;
+            const response = (await this.client.get({ endpoint }));
+            // Cast justified: fromObject typing on Base narrows to M — TS can't prove it structurally.
+            const items = (response.items ?? []).map((item) => this.fromObject(item));
+            return {
+                items,
+                nextCursor: response.next_page_uri
+                    ? encodeCursor(response.next_page_uri)
+                    : null,
+            };
+        }
+        async *all(query = {}) {
+            const seen = new Set();
+            let cursor;
+            let pageCount = 0;
+            while (true) {
+                /* v8 ignore next 5 */
+                if (pageCount >= MAX_PAGES) {
+                    throw new errors_index.PaginationError(`Pagination exceeded ${MAX_PAGES} pages; aborting`);
+                }
+                pageCount += 1;
+                // eslint-disable-next-line no-await-in-loop
+                const { items, nextCursor } = await this.page(query, cursor);
+                if (nextCursor) {
+                    if (nextCursor === cursor || seen.has(nextCursor)) {
+                        throw new errors_index.PaginationError(`Repeated next_page_uri: ${nextCursor}`);
+                    }
+                }
+                // eslint-disable-next-line no-restricted-syntax
+                for (const item of items)
+                    yield item;
+                if (!nextCursor)
+                    return;
+                seen.add(nextCursor);
+                cursor = nextCursor;
+            }
+        }
+    };
+}
+/**
+ * Extracts the top-level path segment(s) from a resource URI, supporting nested paths
+ * (e.g. `/bridge/accounts/AC123` → `bridge/accounts`).
+ *
+ * NOT supported: sub-resource URIs like `/accounts/AC1/refund` — these return
+ * `accounts/AC1` which is not a valid resource key. If the API introduces
+ * sub-resources, extend this helper.
+ */
+function getResourcePath(uri) {
+    if (!uri)
+        return null;
+    const match = uri.match(/^\/([^?]+)\/[^/?]+(?:\?.*)?$/);
+    if (!match)
+        return null;
+    return match[1];
+}
+
+class AccountResource extends Retrievable(Queryable(Resource)) {
+    constructor(client) {
+        super(client, 'accounts', Account.fromObject);
+    }
 }
+var AccountResource$1 = AccountResource;
 
-class File {
-  constructor({ extension, type, url, userId }) {
-    this.extension = extension;
-    this.type = data.enumValueFromString(data.KYCFileType, type);
-    this.url = url;
-    this.userId = userId;
-  }
+class AlertResource extends Creatable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'alerts', Alert.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.AlertUpdateRequest.toCleanObject(req));
+    }
+    async update(alertId, req) {
+        return this._update(alertId, walletTransactionRequest.AlertUpdateRequest.toCleanObject(req));
+    }
+}
+var AlertResource$1 = AlertResource;
 
-  static fromObject = ({ extension, type, url, ...obj }) =>
-    new File({ extension, type, url, userId: obj.user_id });
+class ApiKeyResource extends Creatable(Deactivable(Queryable(Retrievable(Updateable(Resource))))) {
+    constructor(client) {
+        super(client, 'api_keys', ApiKey.fromObject);
+    }
+    async create() {
+        return this._create({});
+    }
+    async deactivate(apiKeyId, minutes = 0) {
+        // Sends { minutes: 0 } as request body on DELETE. The cuenca backend interprets
+        // this as "revoke immediately". Previous implementation omitted the body entirely;
+        // if backend behavior differs, revisit this default (cuenca-js#64 review).
+        return this._deactivate(apiKeyId, { minutes });
+    }
+    async update(apiKeyId, metadata, userId = 'me') {
+        return this._update(apiKeyId, walletTransactionRequest.ApiKeyUpdateRequest.toCleanObject({ userId, metadata }));
+    }
 }
+var ApiKeyResource$1 = ApiKeyResource;
 
-class FraudFundsTransfer {
-  constructor({ transactionId, amount, claveRastreo }) {
-    this.transactionId = transactionId;
-    this.amount = amount;
-    this.claveRastreo = claveRastreo;
-  }
+class ArpcResource extends Creatable(Resource) {
+    constructor(client) {
+        super(client, 'arpc', Arpc.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.ArpcRequest.toObject(req));
+    }
+}
+var ArpcResource$1 = ArpcResource;
+
+const RELATED_TRANSACTION_FACTORIES$1 = {
+    bill_payments: BillPayment.fromObject,
+    card_transactions: CardTransaction.fromObject,
+    commissions: Commission.fromObject,
+    deposits: Deposit.fromObject,
+    savings: Saving.fromObject,
+    transfers: Transfer.fromObject,
+    wallet_transactions: WalletTransaction.fromObject,
+    whatsapp_transfers: WhatsAppTransfer.fromObject,
+};
+const FUNDING_INSTRUMENT_FACTORIES = {
+    ...RELATED_TRANSACTION_FACTORIES$1,
+    accounts: Account.fromObject,
+    cards: Card.fromObject,
+    'bridge/accounts': BridgeAccount.fromObject,
+};
+class BalanceEntryResource extends Queryable(Retrievable(Resource)) {
+    constructor(client) {
+        super(client, 'balance_entries', BalanceEntry.fromObject);
+    }
+    async relatedTransaction(relatedTransactionUri) {
+        const path = getResourcePath(relatedTransactionUri);
+        if (!path)
+            return null;
+        const factory = RELATED_TRANSACTION_FACTORIES$1[path];
+        if (!factory)
+            return null;
+        const response = await this.client.get({ endpoint: relatedTransactionUri });
+        return factory(response);
+    }
+    async fundingInstrument(fundingInstrumentUri) {
+        const path = getResourcePath(fundingInstrumentUri);
+        if (!path)
+            return null;
+        const factory = FUNDING_INSTRUMENT_FACTORIES[path];
+        if (!factory)
+            return null;
+        const response = await this.client.get({ endpoint: fundingInstrumentUri });
+        return factory(response);
+    }
+}
+var BalanceEntryResource$1 = BalanceEntryResource;
 
-  static fromObject = ({ amount, ...obj }) =>
-    new FraudFundsTransfer({
-      transactionId: obj.transaction_id,
-      amount,
-      claveRastreo: obj.clave_rastreo,
-    });
+class BillPaymentResource extends Queryable(Retrievable(Resource)) {
+    constructor(client) {
+        super(client, 'bill_payments', BillPayment.fromObject);
+    }
+    async serviceProvider(providerUri) {
+        if (!providerUri)
+            return null;
+        const response = await this.client.get({ endpoint: providerUri });
+        return ServiceProvider.fromObject(response);
+    }
 }
+var BillPaymentResource$1 = BillPaymentResource;
 
-class KYCValidations {
-  constructor({
-    id,
-    createdAt,
-    updatedAt,
-    deactivatedAt,
-    platformId,
-    filesUri,
-    userId,
-    verificationId,
-    identityId,
-    govtIdStatus,
-    proofOfAddressStatus,
-    proofOfLifeStatus,
-    sourceType,
-    flowId,
-    status,
-    providerUrl,
-  }) {
-    this.id = id;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.deactivatedAt = data.dateToUTC(deactivatedAt);
-    this.platformId = platformId;
-    this.filesUri = filesUri || [];
-    this.userId = userId;
-    this.verificationId = verificationId;
-    this.identityId = identityId;
-    this.govtIdStatus = data.enumValueFromString(data.VerificationStatus, govtIdStatus);
-    this.proofOfAddressStatus = data.enumValueFromString(
-      data.VerificationStatus,
-      proofOfAddressStatus,
-    );
-    this.proofOfLifeStatus = data.enumValueFromString(
-      data.VerificationStatus,
-      proofOfLifeStatus,
-    );
-    this.sourceType = data.enumValueFromString(data.KYCValidationSource, sourceType);
-    this.flowId = flowId;
-    this.status = data.enumValueFromString(data.VerificationStatus, status);
-    this.providerUrl = providerUrl;
-  }
+class BridgeAccountResource extends Queryable(Retrievable(Updateable(Resource))) {
+    constructor(client) {
+        super(client, 'bridge/accounts', BridgeAccount.fromObject);
+    }
+    async update({ userId = 'me', ...req }) {
+        return this._update(userId, walletTransactionRequest.UserUpdateRequest.toCleanObject(req));
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toParams(query) {
+        return vulnerableActivity.toParams$1(query);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toQueryString(query) {
+        return vulnerableActivity.toQueryString$1(query);
+    }
+}
+var BridgeAccountResource$1 = BridgeAccountResource;
 
-  static fromObject = ({ id, status, ...obj }) =>
-    new KYCValidations({
-      id,
-      status,
-      createdAt: obj.created_at,
-      updatedAt: obj.updated_at,
-      deactivatedAt: obj.deactivated_at,
-      platformId: obj.platform_id,
-      filesUri: obj.files_uri,
-      userId: obj.user_id,
-      verificationId: obj.verification_id,
-      identityId: obj.identity_id,
-      govtIdStatus: obj.govt_id_status,
-      proofOfAddressStatus: obj.proof_of_address_status,
-      proofOfLifeStatus: obj.proof_of_life_status,
-      sourceType: obj.source_type,
-      flowId: obj.flow_id,
-      providerUrl: obj.provider_url,
-    });
+class BridgeBankAccountResource extends Retrievable(Queryable(Resource)) {
+    constructor(client) {
+        super(client, 'bridge/bank_accounts', BridgeBankAccount.fromObject);
+    }
 }
+var BridgeBankAccountResource$1 = BridgeBankAccountResource;
 
-class LoginToken {
-  constructor({ id }) {
-    this.id = id;
-  }
+class BridgeClabeResource extends Queryable(Resource) {
+    constructor(client) {
+        super(client, 'bridge/clabes', BridgeClabe.fromObject);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toParams(query) {
+        return vulnerableActivity.toParams$1(query);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toQueryString(query) {
+        return vulnerableActivity.toQueryString$1(query);
+    }
+}
+var BridgeClabeResource$1 = BridgeClabeResource;
 
-  static fromObject = ({ id }) => new LoginToken({ id });
+class BridgeTransactionResource extends Retrievable(Queryable(Resource)) {
+    constructor(client) {
+        super(client, 'bridge/transactions', BridgeTransaction.fromObject);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toParams(query) {
+        return vulnerableActivity.toParams$1(query);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    toQueryString(query) {
+        return vulnerableActivity.toQueryString$1(query);
+    }
 }
+var BridgeTransactionResource$1 = BridgeTransactionResource;
 
-class TransactionalProfile {
-  constructor({
-    currency,
-    monthlyAmount,
-    recipientsNum,
-    payersNum,
-    deposits,
-    withdrawal,
-  }) {
-    this.currency = currency;
-    this.monthlyAmount = monthlyAmount;
+class CardActivationResource extends Creatable(Resource) {
+    constructor(client) {
+        super(client, 'card_activations', CardActivation.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.CardActivationRequest.toCleanObject(req));
+    }
+    async card(cardUri) {
+        if (!cardUri)
+            return null;
+        const response = await this.client.get({ endpoint: cardUri });
+        return Card.fromObject(response);
+    }
+}
+var CardActivationResource$1 = CardActivationResource;
 
-    this.recipientsNum = recipientsNum;
-    this.payersNum = payersNum;
-
-    this.deposits = deposits;
-    this.withdrawal = withdrawal;
-  }
-
-  get deposits() {
-    return this._deposits;
-  }
-
-  set deposits(value) {
-    if (!value) return;
-    this._deposits = vulnerableActivity.TransactionalProfileServices.fromObject(value);
-  }
-
-  get withdrawal() {
-    return this._withdrawal;
-  }
-
-  set withdrawal(value) {
-    if (!value) return;
-    this._withdrawal = vulnerableActivity.TransactionalProfileServices.fromObject(value);
-  }
-
-  static fromObject = ({ currency, deposits, withdrawal, ...obj }) =>
-    new TransactionalProfile({
-      currency,
-      deposits,
-      withdrawal,
-      payersNum: obj.payers_num,
-      recipientsNum: obj.recipients_num,
-      monthlyAmount: obj.monthly_amount,
-    });
-}
-
-class BaseUser {
-  constructor({
-    address,
-    clabe,
-    emailAddress,
-    id,
-    level,
-    meta,
-    nationality,
-    platformId,
-    phoneNumber,
-    requiredLevel,
-    rfc,
-    status,
-    createdAt,
-    updatedAt,
-    userType,
-  }) {
-    this.address = address;
-    this.clabe = clabe;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.emailAddress = emailAddress;
-    this.id = id;
-    this.level = level;
-    this.meta = meta;
-    this.nationality = nationality;
-    this.platformId = platformId;
-    this.phoneNumber = phoneNumber;
-    this.requiredLevel = requiredLevel;
-    this.rfc = rfc;
-    this.status = data.enumValueFromString(data.UserStatus, status);
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.userType = userType;
-  }
-
-  get address() {
-    return this._address;
-  }
-
-  set address(value) {
-    if (!value) return;
-    this._address = vulnerableActivity.Address.fromObject(value);
-  }
-
-  static fromObject = ({
-    address,
-    clabe,
-    id,
-    level,
-    nationality,
-    rfc,
-    status,
-    ...obj
-  }) =>
-    new BaseUser({
-      address,
-      clabe,
-      id,
-      level,
-      meta: obj.meta,
-      nationality,
-      rfc,
-      status,
-      createdAt: obj.created_at,
-      emailAddress: obj.email_address,
-      phoneNumber: obj.phone_number,
-      platformId: obj.platform_id,
-      requiredLevel: obj.required_level,
-      updatedAt: obj.updated_at,
-      userType: obj.user_type,
-    });
-}
-
-class Partner extends BaseUser {
-  constructor({
-    address,
-    audit,
-    businessDetails,
-    businessModel,
-    businessName,
-    clabe,
-    createdAt,
-    documentationUrl,
-    emailAddress,
-    externalAccount,
-    folio,
-    id,
-    incorporationDate,
-    legalName,
-    legalRepresentatives,
-    level,
-    license,
-    meta,
-    nationality,
-    phoneNumber,
-    platformId,
-    requiredLevel,
-    rfc,
-    shareholders,
-    status,
-    transactionalProfile,
-    updatedAt,
-    userId,
-    userType,
-    vulnerableActivity,
-    webSite,
-  }) {
-    super({
-      address,
-      clabe,
-      emailAddress,
-      rfc,
-      id,
-      level,
-      meta,
-      nationality,
-      platformId,
-      phoneNumber,
-      requiredLevel,
-      status,
-      createdAt,
-      updatedAt,
-      userType,
-    });
-    this.audit = audit;
-    this.businessModel = businessModel;
-    this.businessName = businessName;
-    this.businessDetails = businessDetails;
-    this.documentationUrl = documentationUrl;
-    this.incorporationDate = data.dateToUTC(incorporationDate);
-    this.externalAccount = externalAccount;
-    this.folio = folio;
-    this.legalName = legalName;
-    this.license = license;
-    this.shareholders = shareholders;
-    this.legalRepresentatives = legalRepresentatives;
-    this.transactionalProfile = transactionalProfile;
-    this.userId = userId;
-    this.vulnerableActivity = vulnerableActivity;
-    this.webSite = webSite;
-  }
-
-  get shareholders() {
-    return this._shareholders;
-  }
-
-  set shareholders(value) {
-    if (!value) return;
-    this._shareholders = value.map((sh) => vulnerableActivity.ShareholderMoral.fromObject(sh));
-  }
-
-  get legalRepresentatives() {
-    return this._legalRepresentatives;
-  }
-
-  set legalRepresentatives(value) {
-    if (!value) return;
-    this._legalRepresentatives = value.map((lr) =>
-      vulnerableActivity.LegalRepresentatives.fromObject(lr),
-    );
-  }
-
-  get externalAccount() {
-    return this._externalAccount;
-  }
-
-  set externalAccount(value) {
-    if (!value) return;
-    this._externalAccount = vulnerableActivity.ExternalAccount.fromObject(value);
-  }
-
-  get vulnerableActivity() {
-    return this._vulnerableActivity;
-  }
-
-  set vulnerableActivity(value) {
-    if (!value) return;
-    this._vulnerableActivity = vulnerableActivity.VulnerableActivity.fromObject(value);
-  }
-
-  get audit() {
-    return this._audit;
-  }
-
-  set audit(value) {
-    if (!value) return;
-    this._audit = vulnerableActivity.Audit.fromObject(value);
-  }
-
-  get license() {
-    return this._license;
-  }
-
-  set license(value) {
-    if (!value) return;
-    this._license = vulnerableActivity.License.fromObject(value);
-  }
-
-  get transactionalProfile() {
-    return this._transactionalProfile;
-  }
-
-  set transactionalProfile(value) {
-    if (!value) return;
-    this._transactionalProfile = TransactionalProfile.fromObject(value);
-  }
-
-  get businessDetails() {
-    return this._businessDetails;
-  }
-
-  set businessDetails(value) {
-    if (!value) return;
-    this._businessDetails = vulnerableActivity.BusinessDetails.fromObject(value);
-  }
-
-  static fromObject = ({
-    audit,
-    address,
-    clabe,
-    folio,
-    id,
-    level,
-    license,
-    nationality,
-    rfc,
-    status,
-    shareholders,
-    ...obj
-  }) =>
-    new Partner({
-      address,
-      audit,
-      clabe,
-      folio,
-      id,
-      level,
-      license,
-      nationality,
-      rfc,
-      shareholders,
-      status,
-      legalName: obj.legal_name,
-      legalRepresentatives: obj.legal_representatives,
-      businessModel: obj.business_model,
-      businessName: obj.business_name,
-      businessDetails: obj.business_details,
-      createdAt: obj.created_at,
-      documentationUrl: obj.documentation_url,
-      emailAddress: obj.email_address,
-      externalAccount: obj.external_account,
-      incorporationDate: obj.incorporation_date,
-      meta: obj.meta,
-      phoneNumber: obj.phone_number,
-      platformId: obj.platform_id,
-      requiredLevel: obj.required_level,
-      transactionalProfile: obj.transactional_profile,
-      updatedAt: obj.updated_at,
-      userId: obj.user_id,
-      userType: obj.user_type,
-      vulnerableActivity: obj.vulnerable_activity,
-      webSite: obj.web_site,
-    });
-}
-
-class PostalCode {
-  constructor({
-    id,
-    postalCode,
-    colonia,
-    city,
-    state,
-    country,
-    createdAt,
-    updatedAt,
-  }) {
-    this.id = id;
-    this.postalCode = postalCode;
-    this.colonia = colonia;
-    this.city = city;
-    this.state = data.enumValueFromString(data.State, state);
-    this.country = data.enumValueFromString(data.Country, country);
-    this.createdAt = data.dateToUTC(createdAt);
-    this.updatedAt = data.dateToUTC(updatedAt);
-  }
-
-  static fromObject = ({ id, colonia, city, state, country, ...obj }) =>
-    new PostalCode({
-      id,
-      colonia,
-      city,
-      state,
-      country,
-      postalCode: obj.postal_code,
-      createdAt: obj.created_at,
-      updatedAt: obj.updated_at,
-    });
-}
-
-class Wallet {
-  constructor({ balance, createdAt, deactivatedAt, id, userId, updatedAt }) {
-    this.balance = balance;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.deactivatedAt = data.dateToUTC(deactivatedAt);
-    this.id = id;
-    this.userId = userId;
-    this.updatedAt = data.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 = data.enumValueFromString(data.SavingCategory, category);
-    this.goalAmount = goalAmount;
-    this.goalDate = data.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) =>
-    data.enumValueFromString(data.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 Session {
-  constructor({
-    createdAt,
-    expiresAt,
-    failureUrl,
-    id,
-    platformId,
-    successUrl,
-    type,
-    userId,
-  }) {
-    this.createdAt = data.dateToUTC(createdAt);
-    this.expiresAt = data.dateToUTC(expiresAt);
-    this.failureUrl = failureUrl;
-    this.id = id;
-    this.platformId = platformId;
-    this.successUrl = successUrl;
-    this.type = data.enumValueFromString(data.SessionType, type);
-    this.userId = userId;
-  }
-
-  static fromObject = ({ id, type, ...obj }) =>
-    new Session({
-      id,
-      type,
-      createdAt: obj.created_at,
-      expiresAt: obj.expires_at,
-      failureUrl: obj.failure_url,
-      platformId: obj.platform_id,
-      successUrl: obj.success_url,
-      userId: obj.user_id,
-    });
-}
-
-class Statement {
-  constructor({ createdAt, id, month, year }) {
-    this.createdAt = data.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 = data.enumValueFromString(data.TransferNetwork, network);
-    this.recipientName = recipientName;
-    this.trackingKey = trackingKey;
-    this.updatedAt = data.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 User {
-  constructor({
-    address,
-    blacklistValidationStatus,
-    clabe,
-    countryOfBirth,
-    createdAt,
-    curp,
-    curpDocument,
-    dateOfBirth,
-    emailAddress,
-    firstSurname,
-    gender,
-    govtId,
-    id,
-    isDormant,
-    isFraud,
-    isPldBlocked,
-    isSecurityMode,
-    level,
-    names,
-    nationality,
-    phoneNumber,
-    profession,
-    proofOfAddress,
-    proofOfLife,
-    requiredLevel,
-    rfc,
-    secondSurname,
-    stateOfBirth,
-    status,
-    termsOfService,
-    updatedAt,
-    userTosAgreementsId,
-    userType,
-    verificationId,
-    fiscalRegimeCode,
-  }) {
-    this.address = address;
-    this.blacklistValidationStatus = data.enumValueFromString(
-      data.VerificationStatus,
-      blacklistValidationStatus,
-    );
-    this.clabe = clabe;
-    this.countryOfBirth = countryOfBirth;
-    this.createdAt = data.dateToUTC(createdAt);
-    this.curp = curp;
-    this.curpDocument = curpDocument;
-    this.dateOfBirth = dateOfBirth;
-    this.emailAddress = emailAddress;
-    this.firstSurname = firstSurname;
-    this.gender = gender;
-    this.id = id;
-    this.isDormant = isDormant;
-    this.isFraud = isFraud;
-    this.isPldBlocked = isPldBlocked;
-    this.isSecurityMode = isSecurityMode;
-    this.level = level;
-    this.names = names;
-    this.nationality = nationality;
-    this.phoneNumber = phoneNumber;
-    this.profession = profession;
-    this.govtId = govtId;
-    this.proofOfAddress = proofOfAddress;
-    this.proofOfLife = proofOfLife;
-    this.requiredLevel = requiredLevel;
-    this.rfc = rfc;
-    this.secondSurname = secondSurname;
-    this.stateOfBirth = stateOfBirth;
-    this.status = data.enumValueFromString(data.UserStatus, status);
-    this.termsOfService = termsOfService;
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.userTosAgreementsId = userTosAgreementsId;
-    this.userType = userType;
-    this.verificationId = verificationId;
-    this.fiscalRegimeCode = data.enumValueFromString(
-      data.SATRegimeCode,
-      fiscalRegimeCode,
-    );
-  }
-
-  get address() {
-    return this._address;
-  }
-
-  set address(value) {
-    if (!value) return;
-    this._address = vulnerableActivity.Address.fromObject(value);
-  }
-
-  get proofOfAddress() {
-    return this._proofOfAddress;
-  }
-
-  set proofOfAddress(value) {
-    if (!value) return;
-    this._proofOfAddress = vulnerableActivity.KYCFile.fromObject(value);
-  }
-
-  get proofOfLife() {
-    return this._proofOfLife;
-  }
-
-  set proofOfLife(value) {
-    if (!value) return;
-    this._proofOfLife = vulnerableActivity.KYCFile.fromObject(value);
-  }
-
-  get govtId() {
-    return this._govtId;
-  }
-
-  set govtId(value) {
-    if (!value) return;
-    this._govtId = vulnerableActivity.KYCFile.fromObject(value);
-  }
-
-  get termsOfService() {
-    return this._termsOfService;
-  }
-
-  set termsOfService(value) {
-    if (!value) return;
-    this._termsOfService = vulnerableActivity.TOSAgreements.fromObject(value);
-  }
-
-  get curpDocument() {
-    return this._curpDocument;
-  }
-
-  set curpDocument(value) {
-    if (!value) return;
-    this._curpDocument = vulnerableActivity.KYCFile.fromObject(value);
-  }
-
-  static fromObject = ({
-    address,
-    clabe,
-    curp,
-    gender,
-    id,
-    level,
-    names,
-    nationality,
-    profession,
-    rfc,
-    status,
-    ...obj
-  }) =>
-    new User({
-      address,
-      clabe,
-      curp,
-      gender,
-      id,
-      level,
-      names,
-      nationality,
-      profession,
-      rfc,
-      status,
-      blacklistValidationStatus: obj.blacklist_validation_status,
-      countryOfBirth: obj.country_of_birth,
-      createdAt: obj.created_at,
-      curpDocument: obj.curp_document,
-      dateOfBirth: obj.date_of_birth,
-      emailAddress: obj.email_address,
-      firstSurname: obj.first_surname,
-      govtId: obj.govt_id,
-      isDormant: obj.is_dormant,
-      isFraud: obj.is_fraud,
-      isPldBlocked: obj.is_pld_blocked,
-      isSecurityMode: obj.is_security_mode,
-      phoneNumber: obj.phone_number,
-      proofOfAddress: obj.proof_of_address,
-      proofOfLife: obj.proof_of_life,
-      requiredLevel: obj.required_level,
-      secondSurname: obj.second_surname,
-      stateOfBirth: obj.state_of_birth,
-      termsOfService: obj.terms_of_service,
-      updatedAt: obj.updated_at,
-      userTosAgreementsId: obj.user_tos_agreements_id,
-      userType: obj.user_type,
-      verificationId: obj.verification_id,
-      fiscalRegimeCode: obj.fiscal_regime_code,
-    });
-}
-
-class UserCredential {
-  constructor({ createdAt, id, isActive, updatedAt }) {
-    this.createdAt = data.dateToUTC(createdAt);
-    this.id = id;
-    this.isActive = isActive;
-    this.updatedAt = data.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 = data.dateToUTC(lastLoginAt);
-    this.success = success;
-  }
-
-  static fromObject = ({ id, success, ...obj }) =>
-    new UserLogin({
-      id,
-      success,
-      lastLoginAt: obj.last_login_at,
-    });
-}
-
-class UserReport {
-  constructor({
-    actividadEconomica,
-    apellidoMaterno,
-    apellidoMaternoContraparte,
-    apellidoPaterno,
-    apellidoPaternoContraparte,
-    calleDomicilio,
-    ciudadPoblacion,
-    codigoPostal,
-    colonia,
-    committeeMeetingDate,
-    correoElectronico,
-    cuentaClabeContraparte,
-    curp,
-    descripcionOperacion,
-    entidadFederativaDomicilio,
-    fechaNacimientoConstitucion,
-    genero,
-    id,
-    institucionFinanciera,
-    institucionFinancieraContraparte,
-    instrumentoMonetario,
-    isEditable,
-    mainAlertId,
-    mainAlertUri,
-    nacionalidadCuentaAsociada,
-    nacionalidadCuentaContraparte,
-    nivelCuenta,
-    nombre,
-    nombreContraparte,
-    numeroCuentaProyecto,
-    paisNacionalidad,
-    prioridadReporte,
-    razonDenominacionContraparte,
-    razonInusual,
-    regimen,
-    rfc,
-    telefono,
-    tipoOperacionItf,
-    tipoOperacionPerfil,
-    tipoPersona,
-    tipoPersonaContraparte,
-    userId,
-  }) {
-    this.actividadEconomica = actividadEconomica;
-    this.apellidoMaterno = apellidoMaterno;
-    this.apellidoMaternoContraparte = apellidoMaternoContraparte;
-    this.apellidoPaterno = apellidoPaterno;
-    this.apellidoPaternoContraparte = apellidoPaternoContraparte;
-    this.calleDomicilio = calleDomicilio;
-    this.ciudadPoblacion = ciudadPoblacion;
-    this.codigoPostal = codigoPostal;
-    this.colonia = colonia;
-    this.committeeMeetingDate = committeeMeetingDate;
-    this.correoElectronico = correoElectronico;
-    this.cuentaClabeContraparte = cuentaClabeContraparte;
-    this.curp = curp;
-    this.descripcionOperacion = descripcionOperacion;
-    this.entidadFederativaDomicilio = entidadFederativaDomicilio;
-    this.fechaNacimientoConstitucion = fechaNacimientoConstitucion;
-    this.genero = genero;
-    this.id = id;
-    this.institucionFinanciera = institucionFinanciera;
-    this.institucionFinancieraContraparte = institucionFinancieraContraparte;
-    this.instrumentoMonetario = instrumentoMonetario;
-    this.isEditable = isEditable;
-    this.mainAlertId = mainAlertId;
-    this.mainAlertUri = mainAlertUri;
-    this.nacionalidadCuentaAsociada = nacionalidadCuentaAsociada;
-    this.nacionalidadCuentaContraparte = nacionalidadCuentaContraparte;
-    this.nivelCuenta = nivelCuenta;
-    this.nombre = nombre;
-    this.nombreContraparte = nombreContraparte;
-    this.numeroCuentaProyecto = numeroCuentaProyecto;
-    this.paisNacionalidad = paisNacionalidad;
-    this.prioridadReporte = prioridadReporte;
-    this.razonDenominacionContraparte = razonDenominacionContraparte;
-    this.razonInusual = razonInusual;
-    this.regimen = regimen;
-    this.rfc = rfc;
-    this.telefono = telefono;
-    this.tipoOperacionItf = tipoOperacionItf;
-    this.tipoOperacionPerfil = tipoOperacionPerfil;
-    this.tipoPersona = tipoPersona;
-    this.tipoPersonaContraparte = tipoPersonaContraparte;
-    this.userId = userId;
-  }
-
-  static fromObject = ({ id, user_id: userId, ...obj }) =>
-    new UserReport({
-      id,
-      userId,
-      actividadEconomica: obj.actividad_economica,
-      apellidoMaterno: obj.apellido_materno,
-      apellidoMaternoContraparte: obj.apellido_materno_contraparte,
-      apellidoPaterno: obj.apellido_paterno,
-      apellidoPaternoContraparte: obj.apellido_paterno_contraparte,
-      calleDomicilio: obj.calle_domicilio,
-      ciudadPoblacion: obj.ciudad_poblacion,
-      codigoPostal: obj.codigo_postal,
-      colonia: obj.colonia,
-      committeeMeetingDate: obj.committee_meeting_date,
-      correoElectronico: obj.correo_electronico,
-      cuentaClabeContraparte: obj.cuenta_clabe_contraparte,
-      curp: obj.curp,
-      descripcionOperacion: obj.descripcion_operacion,
-      entidadFederativaDomicilio: obj.entidad_federativa_domicilio,
-      fechaNacimientoConstitucion: obj.fecha_nacimiento_constitucion,
-      genero: obj.genero,
-      institucionFinanciera: obj.institucion_financiera,
-      institucionFinancieraContraparte: obj.institucion_financiera_contraparte,
-      instrumentoMonetario: obj.instrumento_monetario,
-      isEditable: obj.is_editable,
-      mainAlertId: obj.main_alert_id,
-      mainAlertUri: obj.main_alert_uri,
-      nacionalidadCuentaAsociada: obj.nacionalidad_cuenta_asociada,
-      nacionalidadCuentaContraparte: obj.nacionalidad_cuenta_contraparte,
-      nivelCuenta: obj.nivel_cuenta,
-      nombre: obj.nombre,
-      nombreContraparte: obj.nombre_contraparte,
-      numeroCuentaProyecto: obj.numero_cuenta_proyecto,
-      paisNacionalidad: obj.pais_nacionalidad,
-      prioridadReporte: obj.prioridad_reporte,
-      razonDenominacionContraparte: obj.razon_denominacion_contraparte,
-      razonInusual: obj.razon_inusual,
-      regimen: obj.regimen,
-      rfc: obj.rfc,
-      telefono: obj.telefono,
-      tipoOperacionItf: obj.tipo_operacion_itf,
-      tipoOperacionPerfil: obj.tipo_operacion_perfil,
-      tipoPersona: obj.tipo_persona,
-      tipoPersonaContraparte: obj.tipo_persona_contraparte,
-    });
-}
-
-class UserTosAgreement {
-  constructor({ createdAt, id, ip, location, type, updatedAt, version }) {
-    this.createdAt = data.dateToUTC(createdAt);
-    this.id = id;
-    this.ip = ip;
-    this.location = location;
-    this.type = type;
-    this.updatedAt = data.dateToUTC(updatedAt);
-    this.version = version;
-  }
-
-  static fromObject = ({ id, ip, location, type, version, ...obj }) =>
-    new UserTosAgreement({
-      id,
-      ip,
-      location,
-      type,
-      version,
-      createdAt: obj.created_at,
-      updatedAt: obj.updated_at,
-    });
-}
-
-class Verification {
-  constructor({ createdAt, id, platformId, recipient, type, updatedAt }) {
-    this.createdAt = data.dateToUTC(createdAt);
-    this.id = id;
-    this.platformId = platformId;
-    this.recipient = recipient;
-    this.type = data.enumValueFromString(data.VerificationType, type);
-    this.updatedAt = data.dateToUTC(updatedAt);
-  }
-
-  static fromObject = ({ id, recipient, type, ...obj }) =>
-    new Verification({
-      id,
-      recipient,
-      type,
-      createdAt: obj.created_at,
-      platformId: obj.platform_id,
-      updatedAt: obj.updated_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 = data.enumValueFromString(
-      data.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 = data.dateToUTC(expiresAt);
-    this.network = data.enumValueFromString(data.TransferNetwork, network);
-    this.phoneNumber = phoneNumber;
-    this.recipientName = recipientName;
-    this.trackingKey = trackingKey;
-    this.updatedAt = data.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),
-    alerts: () => Alert.fromObject(obj),
-    api_keys: () => ApiKey.fromObject(obj),
-    arpc: () => Arpc.fromObject(obj),
-    balance_entries: () => BalanceEntry.fromObject(obj),
-    bill_payments: () => BillPayment.fromObject(obj),
-    'bridge/accounts': () => BridgeAccount.fromObject(obj),
-    'bridge/bank_accounts': () => BridgeBankAccount.fromObject(obj),
-    'bridge/clabes': () => BridgeClabe.fromObject(obj),
-    'bridge/kyc_validations': () => KYCValidations.fromObject(obj),
-    'bridge/sessions': () => Session.fromObject(obj),
-    'bridge/transactions': () => BridgeTransaction.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),
-    files: () => File.fromObject(obj),
-    'support/transfer_fraud_funds': () => FraudFundsTransfer.fromObject(obj),
-    kyc_validations: () => KYCValidations.fromObject(obj),
-    login_tokens: () => LoginToken.fromObject(obj),
-    partners: () => Partner.fromObject(obj),
-    postal_codes: () => PostalCode.fromObject(obj),
-    savings: () => Saving.fromObject(obj),
-    service_providers: () => ServiceProvider.fromObject(obj),
-    sessions: () => Session.fromObject(obj),
-    statements: () => Statement.fromObject(obj),
-    transfers: () => Transfer.fromObject(obj),
-    users: () => User.fromObject(obj),
-    user_credentials: () => UserCredential.fromObject(obj),
-    user_logins: () => UserLogin.fromObject(obj),
-    user_reports: () => UserReport.fromObject(obj),
-    users_tos_agreements: () => UserTosAgreement.fromObject(obj),
-    verifications: () => Verification.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 Uploadable = (SuperClass) =>
-  class Uploadable extends SuperClass {
-    async _upload(data) {
-      const response = await this.client.post({
-        endpoint: `/${this.path}`,
-        data,
-        multipart: true,
-      });
-      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 errors_index.NoResultFound();
-      if (items.length > 1) throw new errors_index.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', vulnerableActivity.AccountQuery, client);
-  }
-}
-
-class AlertResource extends mix(Resource).with(
-  Creatable,
-  Queryable,
-  Retrievable,
-  Updateable,
-) {
-  constructor(client) {
-    super('alerts', vulnerableActivity.AlertQuery, client);
-  }
-
-  async create(req) {
-    const request = new walletTransactionRequest.AlertUpdateRequest(req);
-    const alert = await this._create(request.toCleanObject());
-    return alert;
-  }
-
-  async update(alertId, req) {
-    const request = new walletTransactionRequest.AlertUpdateRequest(req);
-    const alert = await this._update(alertId, request.toCleanObject());
-    return alert;
-  }
-}
-
-class ApiKeyResource extends mix(Resource).with(
-  Creatable,
-  Deactivable,
-  Queryable,
-  Retrievable,
-  Updateable,
-) {
-  constructor(client) {
-    super('api_keys', vulnerableActivity.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 walletTransactionRequest.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 walletTransactionRequest.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', vulnerableActivity.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', vulnerableActivity.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 BridegAccountResource extends mix(Resource).with(
-  Queryable,
-  Updateable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('bridge/accounts', vulnerableActivity.BridgeAccountQuery, client);
-  }
-
-  async update({ userId = 'me', ...req }) {
-    const request = new walletTransactionRequest.UserUpdateRequest(req);
-    const account = await this._update(userId, request.toCleanObject());
-    return account;
-  }
-}
-
-class BridgeBankAccountResource extends mix(Resource).with(
-  Queryable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('bridge/bank_accounts', vulnerableActivity.BridgeBankAccountQuery, client);
-  }
-}
-
-class BridgeClabeResource extends mix(Resource).with(Queryable) {
-  constructor(client) {
-    super('bridge/clabes', vulnerableActivity.BridgeQuery, client);
-  }
+class CardResource extends Creatable(Deactivable(Queryable(Retrievable(Updateable(Resource))))) {
+    constructor(client) {
+        super(client, 'cards', Card.fromObject);
+    }
+    async create(userId, issuer, fundingType) {
+        return this._create(walletTransactionRequest.CardRequest.toCleanObject({ userId, issuer, fundingType }));
+    }
+    async deactivate(cardId) {
+        return this._deactivate(cardId, {});
+    }
+    async update(cardId, status, pinBlock) {
+        return this._update(cardId, walletTransactionRequest.CardUpdateRequest.toCleanObject({
+            status,
+            ...(pinBlock !== undefined ? { pinBlock } : {}),
+        }));
+    }
 }
+var CardResource$1 = CardResource;
 
-class BridgeTransactionResource extends mix(Resource).with(
-  Queryable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('bridge/transactions', vulnerableActivity.BridgeTransactionQuery, client);
-  }
+class CardTransactionResource extends Queryable(Retrievable(Resource)) {
+    constructor(client) {
+        super(client, 'card_transactions', CardTransaction.fromObject);
+    }
+    async relatedCard(relatedCardUri) {
+        if (!relatedCardUri)
+            return null;
+        const response = await this.client.get({ endpoint: relatedCardUri });
+        return Card.fromObject(response);
+    }
 }
+var CardTransactionResource$1 = CardTransactionResource;
 
-class CardActivationResource extends mix(Resource).with(Creatable) {
-  constructor(client) {
-    super('card_activations', Object, client);
-  }
-
-  async create({ number, expMonth, expYear, cvv2 }) {
-    const request = new walletTransactionRequest.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 CardValidationResource extends Creatable(Resource) {
+    constructor(client) {
+        super(client, 'card_validations', CardValidation.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.CardValidationRequest.toCleanObject(req));
+    }
+    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', vulnerableActivity.CardsQuery, client);
-  }
-
-  async create(userId, issuer, fundingType) {
-    const request = new walletTransactionRequest.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 walletTransactionRequest.CardUpdateRequest(status, pinBlock);
-    const card = await this._update(cardId, request.toCleanObject());
-    return card;
-  }
+var CardValidationResource$1 = CardValidationResource;
+
+const RELATED_TRANSACTION_FACTORIES = {
+    bill_payments: BillPayment.fromObject,
+    'bridge/transactions': BridgeTransaction.fromObject,
+    card_transactions: CardTransaction.fromObject,
+    deposits: Deposit.fromObject,
+    savings: Saving.fromObject,
+    transfers: Transfer.fromObject,
+    wallet_transactions: WalletTransaction.fromObject,
+    whatsapp_transfers: WhatsAppTransfer.fromObject,
+};
+class CommissionResource extends Queryable(Retrievable(Resource)) {
+    constructor(client) {
+        super(client, 'commissions', Commission.fromObject);
+    }
+    async relatedTransaction(relatedTransactionUri) {
+        const path = getResourcePath(relatedTransactionUri);
+        if (!path)
+            return null;
+        const factory = RELATED_TRANSACTION_FACTORIES[path];
+        if (!factory)
+            return null;
+        const response = await this.client.get({ endpoint: relatedTransactionUri });
+        return factory(response);
+    }
 }
+var CommissionResource$1 = CommissionResource;
 
-class CardTransactionResource extends mix(Resource).with(
-  Queryable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('card_transactions', vulnerableActivity.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 DepositResource extends Queryable(Retrievable(Resource)) {
+    constructor(client) {
+        super(client, 'deposits', Deposit.fromObject);
+    }
+    async source(sourceUri) {
+        const response = await this.client.get({ endpoint: sourceUri });
+        return Account.fromObject(response);
+    }
 }
+var DepositResource$1 = DepositResource;
 
-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 walletTransactionRequest.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 FileResource extends Downlodable(Uploadable(Resource)) {
+    constructor(client) {
+        super(client, 'files', File.fromObject);
+    }
+    async download(id, { responseType } = {}) {
+        return this._download(id, data.FileFormat.Any, responseType);
+    }
+    async upload(request) {
+        return this._upload(walletTransactionRequest.FileUploadRequest.toObject(request));
+    }
 }
+var FileResource$1 = FileResource;
 
-class CommissionResource extends mix(Resource).with(Queryable, Retrievable) {
-  constructor(client) {
-    super('commissions', vulnerableActivity.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 FraudFundsTransferResource extends Creatable(Resource) {
+    constructor(client) {
+        super(client, 'support/transfer_fraud_funds', FraudFundsTransfer.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.FraudFundsTransferRequest.toObject(req));
+    }
 }
+var FraudFundsTransferResource$1 = FraudFundsTransferResource;
 
-class DepositResource extends mix(Resource).with(Queryable, Retrievable) {
-  constructor(client) {
-    super('deposits', vulnerableActivity.DepositQuery, client);
-  }
-
-  async source(sourceUri) {
-    const response = await this.client.get({ endpoint: sourceUri });
-    return Account.fromObject(response);
-  }
+class KYCValidationsResource extends Creatable(Deactivable(Queryable(Retrievable(Resource)))) {
+    constructor(client, isBridge = false) {
+        super(client, isBridge ? 'bridge/kyc_validations' : 'kyc_validations', KYCValidations.fromObject);
+        this.isBridge = isBridge;
+    }
+    async create(userId = 'me', force = false) {
+        return this._create(walletTransactionRequest.KYCValidationsRequest.toCleanObject({
+            force,
+            userId,
+            isBridge: this.isBridge,
+        }));
+    }
+    async deactivate(kycValidationId) {
+        return this._deactivate(kycValidationId, {});
+    }
 }
+var KYCValidationsResource$1 = KYCValidationsResource;
 
-class FileResource extends mix(Resource).with(Downlodable, Uploadable) {
-  constructor(client) {
-    super('files', Object, client);
-  }
-
-  async download(id) {
-    const byteString = await this._download(id, data.FileFormat.Any);
-    return byteString;
-  }
-
-  async upload(request) {
-    const fileUpload = await this._upload(request);
-    return fileUpload;
-  }
+class LegalPersonResource extends Creatable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'legal_persons', LegalPerson.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.LegalPersonRequest.toCleanObject(req));
+    }
+    async update(legalPersonId, req) {
+        return this._update(legalPersonId, walletTransactionRequest.LegalPersonUpdateRequest.toCleanObject(req));
+    }
 }
+var LegalPersonResource$1 = LegalPersonResource;
 
-class FraudFundsTransferResource extends mix(Resource).with(Creatable) {
-  constructor(client) {
-    super('support/transfer_fraud_funds', Object, client);
-  }
-
-  async create({ userId, amount, concepto, clabe, reason, bankCode }) {
-    const request = new walletTransactionRequest.FraudFundsTransferRequest({
-      userId,
-      amount,
-      concepto,
-      clabe,
-      reason,
-      bankCode,
-    });
-    const fraudFundsTransfer = await this._create(request.toObject());
-    return fraudFundsTransfer;
-  }
+class LoginTokenResource extends Creatable(Resource) {
+    constructor(client) {
+        super(client, 'login_tokens', LoginToken.fromObject);
+    }
+    async create() {
+        return this._create({});
+    }
 }
+var LoginTokenResource$1 = LoginTokenResource;
 
-class KYCValidationsResource extends mix(Resource).with(
-  Creatable,
-  Retrievable,
-  Deactivable,
-  Queryable,
-) {
-  constructor(client, isBridge = false) {
-    super(
-      isBridge ? 'bridge/kyc_validations' : 'kyc_validations',
-      Object,
-      client,
-    );
-    this.isBridge = isBridge;
-  }
-
-  async create(userId = 'me', force = false) {
-    const request = new walletTransactionRequest.KYCValidationsRequest({
-      force,
-      userId,
-      isBridge: this.isBridge,
-    });
-    const kycValidation = await this._create(request.toCleanObject());
-    return kycValidation;
-  }
-
-  async deactivate(kycValidationId) {
-    const response = await this._deactivate(kycValidationId);
-    return response;
-  }
+class OperatorLoginResource extends Creatable(Resource) {
+    constructor(client) {
+        super(client, 'operator-login', OperatorLogin.fromObject);
+        this.sessionIdInHeaders = null;
+    }
+    async create(email, password) {
+        const operatorLogin = await this._create(walletTransactionRequest.OperatorLoginRequest.toCleanObject({ email, password }));
+        if (operatorLogin.sessionToken) {
+            this.sessionIdInHeaders = this.client.addHeadersToRequest({
+                'X-Cuenca-SessionId': operatorLogin.sessionToken,
+            });
+        }
+        return operatorLogin;
+    }
+    clearSessionHeader() {
+        if (this.sessionIdInHeaders) {
+            this.sessionIdInHeaders.eject();
+            this.sessionIdInHeaders = null;
+        }
+    }
 }
+var OperatorLoginResource$1 = OperatorLoginResource;
 
-class LoginTokenResource extends mix(Resource).with(Creatable) {
-  constructor(client) {
-    super('login_tokens', Object, client);
-  }
-
-  async create() {
-    const loginToken = await this._create();
-    return loginToken;
-  }
+class OperatorResource extends Creatable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'operators', Operator.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.OperatorRequest.toCleanObject(req));
+    }
+    async update(operatorId, req) {
+        return this._update(operatorId, walletTransactionRequest.OperatorUpdateRequest.toCleanObject(req));
+    }
 }
+var OperatorResource$1 = OperatorResource;
 
-class PartnerResource extends mix(Resource).with(
-  Creatable,
-  Queryable,
-  Updateable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('partners', vulnerableActivity.PartnerQuery, client);
-  }
-
-  async create(req) {
-    const request = new walletTransactionRequest.PartnerUserRequest(req);
-    const partner = await this._create(request.toCleanObject());
-    return partner;
-  }
-
-  async update(partnerId, req) {
-    const request = new walletTransactionRequest.PartnerUserRequest(req);
-    const partner = await this._update(partnerId, request.toCleanObject());
-    return partner;
-  }
+class PartnerResource extends Creatable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'partners', Partner.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.PartnerUserRequest.toCleanObject(req));
+    }
+    async update(partnerId, req) {
+        return this._update(partnerId, walletTransactionRequest.PartnerUserRequest.toCleanObject(req));
+    }
 }
+var PartnerResource$1 = PartnerResource;
 
-class PostalCodeResource extends mix(Resource).with(Queryable) {
-  constructor(client) {
-    super('postal_codes', vulnerableActivity.PostalCodeQuery, client);
-  }
+class PostalCodeResource extends Queryable(Resource) {
+    constructor(client) {
+        super(client, 'postal_codes', PostalCode.fromObject);
+    }
 }
+var PostalCodeResource$1 = PostalCodeResource;
 
 class ReportResource extends Resource {
-  constructor(client) {
-    super('reports', null, client);
-  }
-
-  async generateXml({ committeeMeetingDate }) {
-    const request = new walletTransactionRequest.ReportGenerateRequest({ committeeMeetingDate });
-
-    let headersInterceptor;
-    let configInterceptor;
-
-    try {
-      headersInterceptor = this.client.addHeadersToRequest({
-        Accept: 'text/xml',
-      });
-      configInterceptor = this.client.addConfigToRequest({
-        responseType: 'arraybuffer',
-      });
-
-      return await this.client.post({
-        endpoint: `/${this.path}`,
-        data: request.toCleanObject(),
-      });
-    } finally {
-      if (headersInterceptor) headersInterceptor.eject();
-      if (configInterceptor) configInterceptor.eject();
+    constructor(client) {
+        super(client, 'reports', (obj) => obj);
+    }
+    async generateXml({ committeeMeetingDate, }) {
+        return this.client.post({
+            endpoint: `/${this.path}`,
+            data: walletTransactionRequest.ReportGenerateRequest.toCleanObject({ committeeMeetingDate }),
+            headers: { Accept: 'text/xml' },
+            responseType: 'arraybuffer',
+        });
     }
-  }
 }
+var ReportResource$1 = ReportResource;
 
-class SavingResource extends mix(Resource).with(
-  Creatable,
-  Deactivable,
-  Queryable,
-  Retrievable,
-  Updateable,
-) {
-  constructor(client) {
-    super('savings', vulnerableActivity.WalletQuery, client);
-  }
-
-  async create(category, goalAmount, goalDate, name) {
-    const request = new walletTransactionRequest.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 walletTransactionRequest.SavingRequest(category, goalAmount, goalDate, name);
-    const saving = await this._update(savingId, request.toObject());
-    return saving;
-  }
+class SavingResource extends Creatable(Deactivable(Queryable(Retrievable(Updateable(Resource))))) {
+    constructor(client) {
+        super(client, 'savings', Saving.fromObject);
+    }
+    async create(category, goalAmount, goalDate, name) {
+        return this._create(walletTransactionRequest.SavingRequest.toObject({ category, goalAmount, goalDate, name }));
+    }
+    async deactivate(savingId) {
+        return this._deactivate(savingId, {});
+    }
+    async update(savingId, category, goalAmount, goalDate, name) {
+        return this._update(savingId, walletTransactionRequest.SavingRequest.toObject({ category, goalAmount, goalDate, name }));
+    }
 }
+var SavingResource$1 = SavingResource;
 
-class ServiceProviderResource extends mix(Resource).with(
-  Queryable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('service_providers', vulnerableActivity.QueryParams, client);
-  }
+class ServiceProviderResource extends Retrievable(Queryable(Resource)) {
+    constructor(client) {
+        super(client, 'service_providers', ServiceProvider.fromObject);
+    }
 }
+var ServiceProviderResource$1 = ServiceProviderResource;
 
-class SessionResource extends mix(Resource).with(
-  Creatable,
-  Retrievable,
-  Queryable,
-) {
-  constructor(client, isBridge = false) {
-    super(isBridge ? 'bridge/sessions' : 'sessions', Object, client);
-    this.isBridge = isBridge;
-  }
-
-  async create(userId, type, successUrl, failureUrl) {
-    const req = new walletTransactionRequest.SessionRequest({
-      failureUrl,
-      successUrl,
-      type,
-      userId,
-      isBridge: this.isBridge,
-    });
-    const session = await this._create(req.toCleanObject());
-    return session;
-  }
+class SessionResource extends Creatable(Queryable(Retrievable(Resource))) {
+    constructor(client, isBridge = false) {
+        super(client, isBridge ? 'bridge/sessions' : 'sessions', Session.fromObject);
+        this.isBridge = isBridge;
+    }
+    async create(userId, type, successUrl, failureUrl) {
+        return this._create(walletTransactionRequest.SessionRequest.toCleanObject({
+            ...(failureUrl !== undefined ? { failureUrl } : {}),
+            ...(successUrl !== undefined ? { successUrl } : {}),
+            type,
+            userId,
+            isBridge: this.isBridge,
+        }));
+    }
 }
+var SessionResource$1 = SessionResource;
 
-class StatementResource extends mix(Resource).with(Downlodable, Queryable) {
-  constructor(client) {
-    super('statements', vulnerableActivity.StatementQuery, client);
-  }
-
-  async pdf(id) {
-    const byteString = await this._download(id, data.FileFormat.Pdf);
-    return byteString;
-  }
-
-  async xml(id) {
-    const byteString = await this._download(id, data.FileFormat.Xml);
-    return byteString;
-  }
-
-  async downloadFiles({ userId, year, month }) {
-    const statement = await this.one(
-      new vulnerableActivity.StatementQuery({ userId, year, month }),
-    );
-    const [pdf, xml] = await Promise.all([
-      this.pdf(statement.id),
-      this.xml(statement.id),
-    ]);
-    return { statement, pdf, xml };
-  }
+class StatementResource extends Downlodable(Queryable(Resource)) {
+    constructor(client) {
+        super(client, 'statements', Statement.fromObject);
+    }
+    async pdf(id) {
+        return this._download(id, data.FileFormat.Pdf);
+    }
+    async xml(id) {
+        return this._download(id, data.FileFormat.Xml);
+    }
+    async downloadFiles({ userId, year, month, }) {
+        vulnerableActivity.validateStatementQuery({ year, month });
+        const statement = await this.one({ userId, year, month });
+        const [pdf, xml] = await Promise.all([
+            this.pdf(statement.id),
+            this.xml(statement.id),
+        ]);
+        return { statement, pdf, xml };
+    }
 }
+var StatementResource$1 = StatementResource;
 
-class TransferResource extends mix(Resource).with(
-  Creatable,
-  Queryable,
-  Retrievable,
-  Updateable,
-) {
-  constructor(client) {
-    super('transfers', vulnerableActivity.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 walletTransactionRequest.TransferRequest(
-      accountNumber,
-      amount,
-      descriptor,
-      key,
-      recipientName,
-    );
-    const transfer = await this._create(request.toCleanObject());
-    return transfer;
-  }
-
-  async update(transferId, req) {
-    const request = new walletTransactionRequest.TransferUpdateRequest(req);
-    const transfer = await this._update(transferId, 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 walletTransactionRequest.TransferRequest(
+class TransferResource extends Creatable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'transfers', Transfer.fromObject);
+    }
+    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 ??
+            TransferResource._genIdempotencyKey(accountNumber, amount);
+        return this._create(walletTransactionRequest.TransferRequest.toCleanObject({
             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] = data.dateToUTC(Date.now()).toISOString().split('T');
-    return `${date}:${accountNumber}:${amount}`;
-  }
+            idempotencyKey: key,
+            ...(recipientName !== undefined ? { recipientName } : {}),
+        }));
+    }
+    async update(transferId, req) {
+        return this._update(transferId, walletTransactionRequest.TransferUpdateRequest.toCleanObject(req));
+    }
+    async createMany(requests) {
+        if (!requests || !Array.isArray(requests) || requests.length === 0) {
+            return {};
+        }
+        const transfers = { submitted: [], errors: [] };
+        await Promise.all(requests.map(async (req) => {
+            const actualRequest = {
+                ...req,
+                idempotencyKey: req.idempotencyKey ??
+                    TransferResource._genIdempotencyKey(req.accountNumber, req.amount),
+            };
+            try {
+                const transfer = await this._create(walletTransactionRequest.TransferRequest.toCleanObject(actualRequest));
+                transfers.submitted.push(transfer);
+            }
+            catch (error) {
+                transfers.errors.push({ actualRequest, error });
+            }
+        }));
+        return transfers;
+    }
+    static _genIdempotencyKey(accountNumber, amount) {
+        const isoDate = data.dateToUTC(Date.now()).toISOString();
+        /* v8 ignore next */
+        const date = isoDate.split('T')[0] ?? '';
+        return `${date}:${accountNumber}:${amount}`;
+    }
 }
+var TransferResource$1 = TransferResource;
 
-class UserCredentialResource extends mix(Resource).with(Creatable, Updateable) {
-  constructor(client) {
-    super('user_credentials', Object, client);
-  }
-
-  async create(password) {
-    const request = new walletTransactionRequest.UserCredentialRequest(password);
-    const credential = await this._create(request.toObject());
-    return credential;
-  }
-
-  async update({ isActive, password, userId = 'me' }) {
-    const request = new walletTransactionRequest.UserCredentialUpdateRequest(password, isActive);
-    const credential = await this._update(userId, request.toCleanObject());
-    return credential;
-  }
+class UserCredentialResource extends Creatable(Updateable(Resource)) {
+    constructor(client) {
+        super(client, 'user_credentials', UserCredential.fromObject);
+    }
+    async create(password) {
+        return this._create(walletTransactionRequest.UserCredentialRequest.toObject({ password }));
+    }
+    async update({ isActive, password, userId = 'me', }) {
+        return this._update(userId, walletTransactionRequest.UserCredentialUpdateRequest.toCleanObject({
+            ...(password !== undefined ? { password } : {}),
+            ...(isActive !== undefined ? { isActive } : {}),
+        }));
+    }
 }
+var UserCredentialResource$1 = UserCredentialResource;
 
-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 walletTransactionRequest.UserLoginRequest(password, userId);
-    const userLogin = await this._create(request.toObject());
-    if (!userLogin.success) throw new errors_index.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 UserLoginResource extends Creatable(Deactivable(Resource)) {
+    constructor(client) {
+        super(client, 'user_logins', UserLogin.fromObject);
+        this.loginIdInHeaders = null;
+    }
+    async create(password, userId) {
+        const userLogin = await this._create(walletTransactionRequest.UserLoginRequest.toObject({ password, userId }));
+        if (!userLogin.success)
+            throw new errors_index.InvalidPassword();
+        this.loginIdInHeaders = this.client.addHeadersToRequest({
+            'X-Cuenca-LoginId': userLogin.id,
+        });
+        return userLogin;
+    }
+    async logOut(userId = 'me') {
+        await this._deactivate(userId, {});
+        if (this.loginIdInHeaders)
+            this.loginIdInHeaders.eject();
+        return true;
+    }
 }
+var UserLoginResource$1 = UserLoginResource;
 
-class UserResourse extends mix(Resource).with(
-  Queryable,
-  Updateable,
-  Retrievable,
-  Deactivable,
-) {
-  constructor(client) {
-    super('users', vulnerableActivity.UserQuery, client);
-  }
-
-  async update({ userId = 'me', ...req }) {
-    const request = new walletTransactionRequest.UserUpdateRequest(req);
-    const user = await this._update(userId, request.toCleanObject());
-    return user;
-  }
-
-  async deactivate(userId) {
-    const response = await this._deactivate(userId);
-    return response;
-  }
+class UserResource extends Deactivable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'users', User.fromObject);
+    }
+    async update({ userId = 'me', ...req }) {
+        return this._update(userId, walletTransactionRequest.UserUpdateRequest.toCleanObject(req));
+    }
+    async deactivate(userId) {
+        return this._deactivate(userId, {});
+    }
 }
+var UserResource$1 = UserResource;
 
-class UserReportResource extends mix(Resource).with(
-  Creatable,
-  Queryable,
-  Retrievable,
-  Updateable,
-) {
-  constructor(client) {
-    super('user_reports', vulnerableActivity.UserReportQuery, client);
-  }
-
-  async create({ committeeMeetingDate, userId }) {
-    const request = new walletTransactionRequest.UserReportCreateRequest({
-      committeeMeetingDate,
-      userId,
-    });
-    return this._create(request.toCleanObject());
-  }
-
-  async update(userReportId, req) {
-    const request = new walletTransactionRequest.UserReportUpdateRequest(req);
-    return this._update(userReportId, request.toCleanObject());
-  }
+class UserReportResource extends Creatable(Queryable(Retrievable(Updateable(Resource)))) {
+    constructor(client) {
+        super(client, 'user_reports', UserReport.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.UserReportCreateRequest.toCleanObject(req));
+    }
+    async update(userReportId, req) {
+        return this._update(userReportId, walletTransactionRequest.UserReportUpdateRequest.toCleanObject(req));
+    }
 }
+var UserReportResource$1 = UserReportResource;
 
-class UsersTosAgreementsResource extends mix(Resource).with(Retrievable) {
-  constructor(client) {
-    super('users_tos_agreements', Object, client);
-  }
+class UsersTosAgreementsResource extends Retrievable(Resource) {
+    constructor(client) {
+        super(client, 'users_tos_agreements', UserTosAgreement.fromObject);
+    }
 }
+var UsersTosAgreementsResource$1 = UsersTosAgreementsResource;
 
-class VerificationResourse extends mix(Resource).with(Creatable, Updateable) {
-  constructor(client) {
-    super('verifications', Object, client);
-  }
-
-  async create({ platformId, recipient, type }) {
-    const request = new walletTransactionRequest.VerificationRequest({ platformId, recipient, type });
-    const verification = await this._create(request.toObject());
-    return verification;
-  }
-
-  async update({ code, id }) {
-    const request = new walletTransactionRequest.VerificationAttemptRequest({ code });
-    const verification = await this._update(id, request.toObject());
-    return verification;
-  }
+class VerificationResource extends Creatable(Updateable(Resource)) {
+    constructor(client) {
+        super(client, 'verifications', Verification.fromObject);
+    }
+    async create(req) {
+        return this._create(walletTransactionRequest.VerificationRequest.toObject(req));
+    }
+    async update({ code, id, }) {
+        return this._update(id, walletTransactionRequest.VerificationAttemptRequest.toObject({ code }));
+    }
 }
+var VerificationResource$1 = VerificationResource;
 
-class WalletTransactionsResource extends mix(Resource).with(
-  Creatable,
-  Queryable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('wallet_transactions', vulnerableActivity.WalletTransactionQuery, client);
-  }
-
-  async create(amount, transactionType, walletUri) {
-    const request = new walletTransactionRequest.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);
-  }
+const WALLET_FACTORIES = {
+    savings: Saving.fromObject,
+};
+class WalletTransactionsResource extends Creatable(Queryable(Retrievable(Resource))) {
+    constructor(client) {
+        super(client, 'wallet_transactions', WalletTransaction.fromObject);
+    }
+    async create(amount, transactionType, walletUri) {
+        return this._create(walletTransactionRequest.WalletTransactionRequest.toObject({ amount, transactionType, walletUri }));
+    }
+    /**
+     * @deprecated Method name has a typo. Retained for API compatibility.
+     * A properly-named alias (`relatedWallet`) will be introduced in v2. See cuenca-js#59.
+     */
+    async realtedWallet(walletUri) {
+        const path = getResourcePath(walletUri);
+        if (!path)
+            return null;
+        const factory = WALLET_FACTORIES[path];
+        if (!factory)
+            return null;
+        const response = await this.client.get({ endpoint: walletUri });
+        return factory(response);
+    }
 }
+var WalletTransactionsResource$1 = WalletTransactionsResource;
 
-class WhatsAppTransferResource extends mix(Resource).with(
-  Queryable,
-  Retrievable,
-) {
-  constructor(client) {
-    super('whatsapp_transfers', vulnerableActivity.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);
-  }
+const ACCOUNT_FACTORIES = {
+    accounts: Account.fromObject,
+    'bridge/accounts': BridgeAccount.fromObject,
+};
+class WhatsAppTransferResource extends Queryable(Retrievable(Resource)) {
+    constructor(client) {
+        super(client, 'whatsapp_transfers', WhatsAppTransfer.fromObject);
+    }
+    async accountDestination(destinationUri) {
+        const path = getResourcePath(destinationUri);
+        if (!path)
+            return null;
+        const factory = ACCOUNT_FACTORIES[path];
+        if (!factory)
+            return null;
+        const response = await this.client.get({ endpoint: destinationUri });
+        return factory(response);
+    }
 }
+var WhatsAppTransferResource$1 = WhatsAppTransferResource;
 
 class Cuenca {
-  constructor({
-    apiKey,
-    apiSecret,
-    language = 'en',
-    phase = data.Phase.Sandbox,
-  } = {}) {
-    this.client = new Client({ apiKey, apiSecret, language, phase });
-    this.withClient(this.client);
-  }
-
-  withClient(client) {
-    this.accounts = new AccountResource(client);
-    this.alerts = new AlertResource(client);
-    this.apiKeys = new ApiKeyResource(client);
-    this.balanceEntries = new BalanceEntryResource(client);
-    this.billPayments = new BillPaymentResource(client);
-    this.bridgeAccounts = new BridegAccountResource(client);
-    this.bridgeBankAccounts = new BridgeBankAccountResource(client);
-    this.bridgeClabes = new BridgeClabeResource(client);
-    this.bridgeKycValidations = new KYCValidationsResource(client, true);
-    this.bridgeSessions = new SessionResource(client, true);
-    this.bridgeTransactions = new BridgeTransactionResource(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.files = new FileResource(client);
-    this.fraudFundsTransfers = new FraudFundsTransferResource(client);
-    this.kycValidations = new KYCValidationsResource(client);
-    this.loginTokens = new LoginTokenResource(client);
-    this.partners = new PartnerResource(client);
-    this.postalCodes = new PostalCodeResource(client);
-    this.reports = new ReportResource(client);
-    this.savings = new SavingResource(client);
-    this.serviceProviders = new ServiceProviderResource(client);
-    this.sessions = new SessionResource(client);
-    this.statements = new StatementResource(client);
-    this.transfers = new TransferResource(client);
-    this.userCredentials = new UserCredentialResource(client);
-    this.userLogins = new UserLoginResource(client);
-    this.users = new UserResourse(client);
-    this.userReports = new UserReportResource(client);
-    this.usersTosAgreements = new UsersTosAgreementsResource(client);
-    this.verifications = new VerificationResourse(client);
-    this.walletTransactions = new WalletTransactionsResource(client);
-    this.whatsAppTransfers = new WhatsAppTransferResource(client);
-  }
+    constructor({ apiKey, apiSecret, language = 'en', phase = data.Phase.Sandbox, } = {}) {
+        // Client type comes from src/client/client.d.ts, a declaration for the
+        // plain-JS class in src/client/client.js. Delete both when the client
+        // migrates to TypeScript (see cuenca-js#66).
+        this.client = new Client({
+            apiKey,
+            apiSecret,
+            language,
+            phase,
+        });
+        this.withClient(this.client);
+    }
+    withClient(client) {
+        this.accounts = new AccountResource$1(client);
+        this.alerts = new AlertResource$1(client);
+        this.apiKeys = new ApiKeyResource$1(client);
+        this.arpc = new ArpcResource$1(client);
+        this.balanceEntries = new BalanceEntryResource$1(client);
+        this.billPayments = new BillPaymentResource$1(client);
+        this.bridgeAccounts = new BridgeAccountResource$1(client);
+        this.bridgeBankAccounts = new BridgeBankAccountResource$1(client);
+        this.bridgeClabes = new BridgeClabeResource$1(client);
+        this.bridgeKycValidations = new KYCValidationsResource$1(client, true);
+        this.bridgeSessions = new SessionResource$1(client, true);
+        this.bridgeTransactions = new BridgeTransactionResource$1(client);
+        this.cardActivations = new CardActivationResource$1(client);
+        this.cards = new CardResource$1(client);
+        this.cardTransactions = new CardTransactionResource$1(client);
+        this.cardValidations = new CardValidationResource$1(client);
+        this.commissions = new CommissionResource$1(client);
+        this.deposits = new DepositResource$1(client);
+        this.files = new FileResource$1(client);
+        this.fraudFundsTransfers = new FraudFundsTransferResource$1(client);
+        this.kycValidations = new KYCValidationsResource$1(client);
+        this.legalPersons = new LegalPersonResource$1(client);
+        this.loginTokens = new LoginTokenResource$1(client);
+        this.operatorLogins = new OperatorLoginResource$1(client);
+        this.operators = new OperatorResource$1(client);
+        this.partners = new PartnerResource$1(client);
+        this.postalCodes = new PostalCodeResource$1(client);
+        this.reports = new ReportResource$1(client);
+        this.savings = new SavingResource$1(client);
+        this.serviceProviders = new ServiceProviderResource$1(client);
+        this.sessions = new SessionResource$1(client);
+        this.statements = new StatementResource$1(client);
+        this.transfers = new TransferResource$1(client);
+        this.userCredentials = new UserCredentialResource$1(client);
+        this.userLogins = new UserLoginResource$1(client);
+        this.users = new UserResource$1(client);
+        this.userReports = new UserReportResource$1(client);
+        this.usersTosAgreements = new UsersTosAgreementsResource$1(client);
+        this.verifications = new VerificationResource$1(client);
+        this.walletTransactions = new WalletTransactionsResource$1(client);
+        this.whatsAppTransfers = new WhatsAppTransferResource$1(client);
+    }
 }
 
 exports.Cuenca = Cuenca;