@ramiidv/arca-mtxca 0.3.0 → 0.5.0

package/dist/mtxca-client.js

@@ -1,19 +1,34 @@
-import { afipSoapCall, checkServiceErrors } from '@ramiidv/arca-common';
+import { ArcaSoapError, checkServiceErrors, parseServerStatus, SoapServiceClient } from '@ramiidv/arca-common';
+import { decodeResponse, encodeRequest } from '@ramiidv/arca-common/schema';
 import { MTXCA_NAMESPACE } from './constants.js';
-import { buildComprobante, XsdFields } from './serialize.js';
-import { ResponseReader } from './parse.js';
+import { ACTIVIDADES_VIGENTES_RESPONSE, CAEA_ENTRE_FECHAS_RESPONSE, CAEA_NO_UTILIZADO, CAEA_NO_UTILIZADO_PTO_VTA, CAEA_RESPONSE, COMPROBANTE_CAE_RESPONSE, COMPROBANTE_CAEA_RESPONSE, CON_CAEA, CON_CAEA_PTO_VTA, CONDICIONES_IVA_RECEPTOR_RESPONSE, CONSULTA_COMPROBANTE, CONSULTA_COMPROBANTE_RESPONSE, CONSULTA_CONDICIONES_IVA, CONSULTA_ULTIMO, COTIZACION, COTIZACION_RESPONSE, ENTRE_FECHAS, FECHA_PROCESO, PARAMETROS, PUNTOS_VENTA_RESPONSE, RESULTADO, SOLICITUD_CAEA, ULTIMO_RESPONSE, } from './schemas.js';
+import { buildComprobante, encodeConCaea } from './serialize.js';
 const SERVICE = 'WSMTXCA';
 function isResultado(value) {
     return value === 'A' || value === 'O' || value === 'R';
 }
-function validated(build) {
-    const f = new XsdFields();
-    const value = build(f);
-    f.throwIfErrors('Parámetros inválidos');
-    return value;
+/**
+ * Respuesta ilegible: `ArcaSoapError` (`uncertain` en emisiones: el
+ * comprobante pudo haberse procesado aunque la respuesta no se pueda leer).
+ */
+function invalid(message, kind) {
+    return new ArcaSoapError(message, { uncertain: kind === 'emision' });
+}
+function decode(node, schema, path, kind) {
+    return decodeResponse(node, schema, path, { error: (m) => invalid(m, kind) });
+}
+/**
+ * Elemento obligatorio del XSD que el DSL no verifica: un contenedor de lista
+ * (`[]` si viene vacío) o un elemento complejo (`complex`: tiene que tener hijos).
+ */
+function requerido(node, key, path, kind, complex = false) {
+    const v = node[key];
+    const ok = complex ? v !== null && typeof v === 'object' && !Array.isArray(v) : v !== undefined && v !== null;
+    if (!ok)
+        throw invalid(`Respuesta inválida: falta ${path}.${key}`, kind);
 }
-function validCaea(caea) {
-    return validated((f) => f.codigoAutorizacion('caea', caea, true));
+function toCAEA({ CAEA, arrayObservaciones, ...rest }) {
+    return { ...rest, caea: CAEA, observaciones: arrayObservaciones };
 }
 /**
  * Cliente de bajo nivel de WSMTXCA: una función por operación del WSDL. No
@@ -25,30 +40,26 @@ function validCaea(caea) {
  *   `kind: 'emision'`: no se reintentan y, si no hay respuesta, el
  *   `ArcaSoapError` tiene `uncertain: true`.
  */
-export class MtxcaClient {
-    config;
+export class MtxcaClient extends SoapServiceClient {
     constructor(config) {
         if (!config?.endpoint)
             throw new TypeError('MtxcaClient: endpoint es obligatorio');
-        this.config = config;
-    }
-    get endpoint() {
-        return this.config.endpoint;
+        const { endpoint, timeout, retries, retryDelayMs, onEvent, fetch, legacyTls } = config;
+        super({
+            endpoint,
+            namespace: MTXCA_NAMESPACE,
+            transport: { timeout, retries, retryDelayMs, onEvent, fetch, legacyTls },
+        });
     }
     call(method, params, kind, opts, requestElement = `${method}Request`) {
-        const { endpoint, timeout, retries, retryDelayMs, onEvent, fetch, legacyTls } = this.config;
-        return afipSoapCall(endpoint, MTXCA_NAMESPACE, method, params, {
-            timeout,
-            retries,
-            retryDelayMs,
-            onEvent,
-            fetch,
-            legacyTls,
+        return this.soapCall(method, params, {
             kind,
             signal: opts?.signal,
             requestElement,
             responseElement: `${method}Response`,
             soapActionFromMethod: true,
+            // Todo como texto: los schemas convierten cada campo según el XSD.
+            parseNumbers: false,
         });
     }
     static authRequest(auth) {
@@ -69,13 +80,7 @@ export class MtxcaClient {
     // =========================================================================
     /** `dummy`: estado de los servidores. No requiere autenticación. */
     async dummy(opts) {
-        const result = await this.call('dummy', {}, 'consulta', opts, null);
-        const r = new ResponseReader('dummy', 'consulta');
-        return {
-            appserver: r.str(result, 'appserver'),
-            authserver: r.str(result, 'authserver'),
-            dbserver: r.str(result, 'dbserver'),
-        };
+        return parseServerStatus(await this.call('dummy', {}, 'consulta', opts, null));
     }
     // =========================================================================
     // CAE
@@ -95,44 +100,32 @@ export class MtxcaClient {
     async autorizarCAE(method, auth, comprobante, opts) {
         const comprobanteCAERequest = buildComprobante(comprobante, 'cae');
         const result = await this.callAuth(method, auth, { comprobanteCAERequest }, 'emision', opts);
-        const r = new ResponseReader(method, 'emision');
-        const resultado = this.resultado(r, result, method);
-        const base = {
-            observaciones: r.codigosDescripciones(result['arrayObservaciones'], 'arrayObservaciones'),
-            errores: r.codigosDescripciones(result['arrayErrores'], 'arrayErrores'),
-            evento: r.evento(result),
-        };
+        const { resultado, base } = this.resultado(result, method);
         if (resultado === 'R')
             return { resultado, ...base };
-        const cr = r.obj(result, 'comprobanteResponse');
-        return {
-            resultado,
-            comprobante: {
-                cuit: r.str(cr, 'cuit', 'comprobanteResponse.cuit'),
-                codigoTipoComprobante: r.num(cr, 'codigoTipoComprobante', 'comprobanteResponse.codigoTipoComprobante'),
-                numeroPuntoVenta: r.num(cr, 'numeroPuntoVenta', 'comprobanteResponse.numeroPuntoVenta'),
-                numeroComprobante: r.num(cr, 'numeroComprobante', 'comprobanteResponse.numeroComprobante'),
-                fechaEmision: r.str(cr, 'fechaEmision', 'comprobanteResponse.fechaEmision'),
-                cae: r.str(cr, 'CAE', 'comprobanteResponse.CAE'),
-                fechaVencimientoCAE: r.str(cr, 'fechaVencimientoCAE', 'comprobanteResponse.fechaVencimientoCAE'),
-            },
-            ...base,
-        };
+        requerido(result, 'comprobanteResponse', method, 'emision', true);
+        const { CAE, ...cr } = decode(result['comprobanteResponse'], COMPROBANTE_CAE_RESPONSE, `${method}.comprobanteResponse`, 'emision');
+        return { resultado, comprobante: { ...cr, cae: CAE }, ...base };
     }
     /**
-     * `resultado` es obligatorio. Si falta y hay `arrayErrores`, es un rechazo
+     * Decodifica `resultado`, `arrayObservaciones`, `arrayErrores` y `evento`.
+     * `resultado` es obligatorio: si falta y hay `arrayErrores`, es un rechazo
      * (`ArcaServiceError`); si falta sin errores, la respuesta es ilegible
      * (`ArcaSoapError` con `uncertain`).
      */
-    resultado(r, result, method) {
-        if (!r.has(result, 'resultado')) {
+    resultado(result, method, schema = RESULTADO) {
+        const r = decode(result, schema, method, 'emision');
+        if (!r.resultado) {
             checkServiceErrors(result, `${SERVICE} ${method}`);
-            throw r.invalid('resultado');
+            throw invalid(`Respuesta inválida: falta ${method}.resultado`, 'emision');
         }
-        const resultado = r.str(result, 'resultado');
-        if (!isResultado(resultado))
-            throw r.invalid('resultado', `valor "${resultado}" inesperado en`);
-        return resultado;
+        if (!isResultado(r.resultado)) {
+            throw invalid(`Respuesta inválida: valor "${r.resultado}" inesperado en ${method}.resultado`, 'emision');
+        }
+        return {
+            resultado: r.resultado,
+            base: { observaciones: r.arrayObservaciones, errores: r.arrayErrores, evento: r.evento },
+        };
     }
     // =========================================================================
     // CAEA
@@ -143,44 +136,33 @@ export class MtxcaClient {
      * resultado es incierto, recuperalo con `consultarCAEAEntreFechas`.
      */
     async solicitarCAEA(auth, periodo, orden, opts) {
-        const solicitudCAEA = validated((f) => {
-            const p = f.int('periodo', periodo, true, 190001, 999912);
-            if (p !== undefined && (p % 100 < 1 || p % 100 > 12))
-                f.fail('periodo', 'formato AAAAMM', periodo);
-            return { periodo: p, orden: f.int('orden', orden, true, 1, 2) };
+        const solicitudCAEA = encodeRequest({ periodo, orden }, SOLICITUD_CAEA, 'solicitarCAEA', (i, errors) => {
+            const p = i['periodo'];
+            if (Number.isInteger(p) && (p % 100 < 1 || p % 100 > 12)) {
+                errors.push({ field: 'periodo', message: 'periodo: debe tener formato AAAAMM (mes 01 a 12)', value: p });
+            }
         });
         const result = await this.callAuth('solicitarCAEA', auth, { solicitudCAEA }, 'emision', opts);
         checkServiceErrors(result, `${SERVICE} solicitarCAEA`);
-        const r = new ResponseReader('solicitarCAEA', 'emision');
-        return this.parseCAEA(r, r.obj(result, 'CAEAResponse'), 'CAEAResponse');
+        return this.parseCAEA(result, 'solicitarCAEA', 'emision');
     }
     /** `consultarCAEA`: datos de un CAEA otorgado. */
     async consultarCAEA(auth, caea, opts) {
-        const result = await this.consulta('consultarCAEA', auth, { CAEA: validCaea(caea) }, opts);
-        const r = new ResponseReader('consultarCAEA', 'consulta');
-        return this.parseCAEA(r, r.obj(result, 'CAEAResponse'), 'CAEAResponse');
+        const params = encodeConCaea({ caea }, CON_CAEA, 'consultarCAEA');
+        const result = await this.consulta('consultarCAEA', auth, params, opts);
+        return this.parseCAEA(result, 'consultarCAEA', 'consulta');
+    }
+    /** `CAEAResponse` obligatorio de `solicitarCAEA` / `consultarCAEA`. */
+    parseCAEA(result, method, kind) {
+        requerido(result, 'CAEAResponse', method, kind, true);
+        return toCAEA(decode(result['CAEAResponse'], CAEA_RESPONSE, `${method}.CAEAResponse`, kind));
     }
     /** `consultarCAEAEntreFechas`: CAEAs otorgados con vigencia entre dos fechas. */
     async consultarCAEAEntreFechas(auth, fechaDesde, fechaHasta, opts) {
-        const params = validated((f) => ({
-            fechaDesde: f.date('fechaDesde', fechaDesde, true),
-            fechaHasta: f.date('fechaHasta', fechaHasta, true),
-        }));
+        const params = encodeRequest({ fechaDesde, fechaHasta }, ENTRE_FECHAS, 'consultarCAEAEntreFechas');
         const result = await this.consulta('consultarCAEAEntreFechas', auth, params, opts);
-        const r = new ResponseReader('consultarCAEAEntreFechas', 'consulta');
-        return r.list(result['arrayCAEAResponse'], 'CAEAResponse').map((c, i) => this.parseCAEA(r, c, `arrayCAEAResponse.CAEAResponse[${i}]`));
-    }
-    parseCAEA(r, c, path) {
-        return {
-            fechaProceso: r.str(c, 'fechaProceso', `${path}.fechaProceso`),
-            caea: r.str(c, 'CAEA', `${path}.CAEA`),
-            periodo: r.num(c, 'periodo', `${path}.periodo`),
-            orden: r.num(c, 'orden', `${path}.orden`),
-            fechaDesde: r.str(c, 'fechaDesde', `${path}.fechaDesde`),
-            fechaHasta: r.str(c, 'fechaHasta', `${path}.fechaHasta`),
-            fechaTopeInforme: r.str(c, 'fechaTopeInforme', `${path}.fechaTopeInforme`),
-            observaciones: r.codigosDescripciones(c['arrayObservaciones'], `${path}.arrayObservaciones`),
-        };
+        const { arrayCAEAResponse } = decode(result, CAEA_ENTRE_FECHAS_RESPONSE, 'consultarCAEAEntreFechas', 'consulta');
+        return arrayCAEAResponse.map(toCAEA);
     }
     /** `informarComprobanteCAEA`. Un rechazo devuelve `resultado: 'R'` con `errores`. */
     async informarComprobanteCAEA(auth, comprobante, opts) {
@@ -193,57 +175,54 @@ export class MtxcaClient {
     async informarCAEA(method, auth, comprobante, opts) {
         const comprobanteCAEARequest = buildComprobante(comprobante, 'caea');
         const result = await this.callAuth(method, auth, { comprobanteCAEARequest }, 'emision', opts);
-        const r = new ResponseReader(method, 'emision');
-        const resultado = this.resultado(r, result, method);
-        const base = {
-            observaciones: r.codigosDescripciones(result['arrayObservaciones'], 'arrayObservaciones'),
-            errores: r.codigosDescripciones(result['arrayErrores'], 'arrayErrores'),
-            evento: r.evento(result),
-        };
+        const { resultado, base } = this.resultado(result, method);
+        const { fechaProceso } = decode(result, FECHA_PROCESO, method, 'emision');
         if (resultado === 'R')
-            return { resultado, fechaProceso: r.optStr(result, 'fechaProceso'), ...base };
-        const cr = r.obj(result, 'comprobanteCAEAResponse');
-        return {
-            resultado,
-            fechaProceso: r.str(result, 'fechaProceso'),
-            comprobante: {
-                caea: r.str(cr, 'CAEA', 'comprobanteCAEAResponse.CAEA'),
-                codigoTipoComprobante: r.num(cr, 'codigoTipoComprobante', 'comprobanteCAEAResponse.codigoTipoComprobante'),
-                numeroPuntoVenta: r.num(cr, 'numeroPuntoVenta', 'comprobanteCAEAResponse.numeroPuntoVenta'),
-                numeroComprobante: r.num(cr, 'numeroComprobante', 'comprobanteCAEAResponse.numeroComprobante'),
-            },
-            ...base,
-        };
+            return { resultado, fechaProceso, ...base };
+        if (fechaProceso === undefined)
+            throw invalid(`Respuesta inválida: falta ${method}.fechaProceso`, 'emision');
+        requerido(result, 'comprobanteCAEAResponse', method, 'emision', true);
+        const { CAEA, ...cr } = decode(result['comprobanteCAEAResponse'], COMPROBANTE_CAEA_RESPONSE, `${method}.comprobanteCAEAResponse`, 'emision');
+        return { resultado, fechaProceso, comprobante: { caea: CAEA, ...cr }, ...base };
     }
     /** `informarCAEANoUtilizado`: informa que un CAEA no se usó en ningún punto de venta. */
     async informarCAEANoUtilizado(auth, caea, opts) {
-        return this.caeaNoUtilizado('informarCAEANoUtilizado', auth, { CAEA: validCaea(caea) }, opts);
+        const method = 'informarCAEANoUtilizado';
+        return this.caeaNoUtilizado(method, auth, encodeConCaea({ caea }, CON_CAEA, method), CAEA_NO_UTILIZADO, opts);
     }
     /** `informarCAEANoUtilizadoPtoVta`: informa que un CAEA no se usó en un punto de venta. */
     async informarCAEANoUtilizadoPtoVta(auth, caea, numeroPuntoVenta, opts) {
-        const ptoVta = validated((f) => f.int('numeroPuntoVenta', numeroPuntoVenta, true, 1, 99998));
-        return this.caeaNoUtilizado('informarCAEANoUtilizadoPtoVta', auth, { CAEA: validCaea(caea), numeroPuntoVenta: ptoVta }, opts);
+        const method = 'informarCAEANoUtilizadoPtoVta';
+        const params = encodeConCaea({ caea, numeroPuntoVenta }, CON_CAEA_PTO_VTA, method);
+        return this.caeaNoUtilizado(method, auth, params, CAEA_NO_UTILIZADO_PTO_VTA, opts);
     }
-    async caeaNoUtilizado(method, auth, params, opts) {
+    async caeaNoUtilizado(method, auth, params, schema, opts) {
         const result = await this.callAuth(method, auth, params, 'emision', opts);
-        const r = new ResponseReader(method, 'emision');
-        const resultado = this.resultado(r, result, method);
-        const aprobado = resultado !== 'R';
+        const { resultado, base } = this.resultado(result, method, schema);
+        const r = decode(result, schema, method, 'emision');
         const conPtoVta = 'numeroPuntoVenta' in params;
+        // Obligatorios en el XSD; en un rechazo se toleran ausentes.
+        const faltante = [
+            r.fechaProceso === undefined && 'fechaProceso',
+            r.CAEA === undefined && 'CAEA',
+            conPtoVta && r.numeroPuntoVenta === undefined && 'numeroPuntoVenta',
+        ].find(Boolean);
+        if (resultado !== 'R' && faltante)
+            throw invalid(`Respuesta inválida: falta ${method}.${faltante}`, 'emision');
         return {
             resultado,
-            fechaProceso: aprobado ? r.str(result, 'fechaProceso') : r.optStr(result, 'fechaProceso'),
-            caea: aprobado ? r.str(result, 'CAEA') : r.optStr(result, 'CAEA'),
-            ...(conPtoVta ? { numeroPuntoVenta: aprobado ? r.num(result, 'numeroPuntoVenta') : r.optNum(result, 'numeroPuntoVenta') } : {}),
-            errores: r.codigosDescripciones(result['arrayErrores'], 'arrayErrores'),
-            evento: r.evento(result),
+            fechaProceso: r.fechaProceso,
+            caea: r.CAEA,
+            ...(conPtoVta ? { numeroPuntoVenta: r.numeroPuntoVenta } : {}),
+            errores: base.errores,
+            evento: base.evento,
         };
     }
     /** `consultarPtosVtaCAEANoInformados`: puntos de venta que todavía no informaron movimientos para el CAEA. */
     async consultarPtosVtaCAEANoInformados(auth, caea, opts) {
-        const result = await this.consulta('consultarPtosVtaCAEANoInformados', auth, { CAEA: validCaea(caea) }, opts);
-        const r = new ResponseReader('consultarPtosVtaCAEANoInformados', 'consulta');
-        return this.parsePuntosVenta(r, r.list(result['arrayPuntosVenta'], 'puntoVenta'));
+        const method = 'consultarPtosVtaCAEANoInformados';
+        const result = await this.consulta(method, auth, encodeConCaea({ caea }, CON_CAEA, method), opts);
+        return this.parsePuntosVenta(result, method);
     }
     // =========================================================================
     // Consultas de comprobantes
@@ -254,100 +233,101 @@ export class MtxcaClient {
      * y tipo); `ArcaMtxca.ultimoComprobante` lo traduce a 0.
      */
     async consultarUltimoComprobanteAutorizado(auth, ptoVta, cbteTipo, opts) {
-        const consultaUltimoComprobanteAutorizadoRequest = validated((f) => ({
-            codigoTipoComprobante: f.int('cbteTipo', cbteTipo, true),
-            numeroPuntoVenta: f.int('ptoVta', ptoVta, true, 1, 99998),
-        }));
-        const result = await this.consulta('consultarUltimoComprobanteAutorizado', auth, { consultaUltimoComprobanteAutorizadoRequest }, opts);
-        return new ResponseReader('consultarUltimoComprobanteAutorizado', 'consulta').num(result, 'numeroComprobante');
+        const method = 'consultarUltimoComprobanteAutorizado';
+        const consultaUltimoComprobanteAutorizadoRequest = encodeRequest({ codigoTipoComprobante: cbteTipo, numeroPuntoVenta: ptoVta }, CONSULTA_ULTIMO, method);
+        const result = await this.consulta(method, auth, { consultaUltimoComprobanteAutorizadoRequest }, opts);
+        return decode(result, ULTIMO_RESPONSE, method, 'consulta').numeroComprobante;
     }
     /** `consultarComprobante`: datos de un comprobante autorizado (CAE) o informado (CAEA). */
     async consultarComprobante(auth, cbteTipo, ptoVta, cbteNro, opts) {
-        const consultaComprobanteRequest = validated((f) => ({
-            codigoTipoComprobante: f.int('cbteTipo', cbteTipo, true),
-            numeroPuntoVenta: f.int('ptoVta', ptoVta, true, 1, 99998),
-            numeroComprobante: f.int('cbteNro', cbteNro, true, 1, 99999999),
-        }));
-        const result = await this.consulta('consultarComprobante', auth, { consultaComprobanteRequest }, opts);
-        const r = new ResponseReader('consultarComprobante', 'consulta');
+        const method = 'consultarComprobante';
+        const consultaComprobanteRequest = encodeRequest({ codigoTipoComprobante: cbteTipo, numeroPuntoVenta: ptoVta, numeroComprobante: cbteNro }, CONSULTA_COMPROBANTE, method);
+        const result = await this.consulta(method, auth, { consultaComprobanteRequest }, opts);
+        requerido(result, 'comprobante', method, 'consulta', true);
+        requerido(result['comprobante'], 'arrayItems', `${method}.comprobante`, 'consulta');
+        const r = decode(result, CONSULTA_COMPROBANTE_RESPONSE, method, 'consulta');
+        const { arrayComprobantesAsociados, arrayOtrosTributos, arrayItems, arraySubtotalesIVA, arrayDatosAdicionales, arrayCompradores, arrayActividades, ...c } = r.comprobante;
         return {
-            comprobante: parseComprobante(r, r.obj(result, 'comprobante')),
-            observaciones: r.codigosDescripciones(result['arrayObservaciones'], 'arrayObservaciones'),
-            evento: r.evento(result),
+            comprobante: {
+                ...c,
+                comprobantesAsociados: arrayComprobantesAsociados,
+                otrosTributos: arrayOtrosTributos,
+                items: arrayItems,
+                subtotalesIVA: arraySubtotalesIVA,
+                datosAdicionales: arrayDatosAdicionales,
+                compradores: arrayCompradores,
+                actividades: arrayActividades.map((a) => a.codigo),
+            },
+            observaciones: r.arrayObservaciones,
+            evento: r.evento,
         };
     }
     // =========================================================================
     // Parámetros
     // =========================================================================
-    async codigos(method, container, auth, opts, params = {}) {
-        const result = await this.consulta(method, auth, params, opts);
-        const r = new ResponseReader(method, 'consulta');
-        return r.requiredList(result, container, 'codigoDescripcion').map((cd, i) => r.codigoDescripcion(cd, `${container}[${i}]`));
+    /** Consulta cuya respuesta es un `ArrayCodigosDescripciones[String]Type` obligatorio (ver `PARAMETROS`). */
+    async codigos(method, auth, opts) {
+        const schema = PARAMETROS[method];
+        const [container] = Object.keys(schema);
+        const result = await this.consulta(method, auth, {}, opts);
+        requerido(result, container, method, 'consulta');
+        return decode(result, schema, method, 'consulta')[container];
     }
     consultarTiposComprobante(auth, opts) {
-        return this.codigos('consultarTiposComprobante', 'arrayTiposComprobante', auth, opts);
+        return this.codigos('consultarTiposComprobante', auth, opts);
     }
     consultarTiposDocumento(auth, opts) {
-        return this.codigos('consultarTiposDocumento', 'arrayTiposDocumento', auth, opts);
+        return this.codigos('consultarTiposDocumento', auth, opts);
     }
     consultarAlicuotasIVA(auth, opts) {
-        return this.codigos('consultarAlicuotasIVA', 'arrayAlicuotasIVA', auth, opts);
+        return this.codigos('consultarAlicuotasIVA', auth, opts);
     }
     consultarCondicionesIVA(auth, opts) {
-        return this.codigos('consultarCondicionesIVA', 'arrayCondicionesIVA', auth, opts);
+        return this.codigos('consultarCondicionesIVA', auth, opts);
     }
     /** Condiciones de IVA del receptor admitidas para un tipo de comprobante (RG 5616). */
     async consultarCondicionesIVAReceptor(auth, cbteTipo, opts) {
-        const consultaCondicionesIVAReceptorRequest = validated((f) => ({ codigoTipoComprobante: f.int('cbteTipo', cbteTipo, true) }));
-        const result = await this.consulta('consultarCondicionesIVAReceptor', auth, { consultaCondicionesIVAReceptorRequest }, opts);
-        const r = new ResponseReader('consultarCondicionesIVAReceptor', 'consulta');
-        return r.codigosDescripciones(result['arrayCondicionesIVAReceptor'], 'arrayCondicionesIVAReceptor');
+        const method = 'consultarCondicionesIVAReceptor';
+        const consultaCondicionesIVAReceptorRequest = encodeRequest({ codigoTipoComprobante: cbteTipo }, CONSULTA_CONDICIONES_IVA, method);
+        const result = await this.consulta(method, auth, { consultaCondicionesIVAReceptorRequest }, opts);
+        return decode(result, CONDICIONES_IVA_RECEPTOR_RESPONSE, method, 'consulta').arrayCondicionesIVAReceptor;
     }
     consultarUnidadesMedida(auth, opts) {
-        return this.codigos('consultarUnidadesMedida', 'arrayUnidadesMedida', auth, opts);
+        return this.codigos('consultarUnidadesMedida', auth, opts);
     }
     consultarTiposTributo(auth, opts) {
-        return this.codigos('consultarTiposTributo', 'arrayTiposTributo', auth, opts);
+        return this.codigos('consultarTiposTributo', auth, opts);
     }
     consultarTiposDatosAdicionales(auth, opts) {
-        return this.codigos('consultarTiposDatosAdicionales', 'arrayTiposDatosAdicionales', auth, opts);
+        return this.codigos('consultarTiposDatosAdicionales', auth, opts);
     }
-    async consultarMonedas(auth, opts) {
-        const result = await this.consulta('consultarMonedas', auth, {}, opts);
-        const r = new ResponseReader('consultarMonedas', 'consulta');
-        return r.requiredList(result, 'arrayMonedas', 'codigoDescripcion').map((m, i) => ({
-            codigo: r.str(m, 'codigo', `arrayMonedas[${i}].codigo`),
-            descripcion: r.str(m, 'descripcion', `arrayMonedas[${i}].descripcion`),
-        }));
+    consultarMonedas(auth, opts) {
+        return this.codigos('consultarMonedas', auth, opts);
     }
     /**
      * `consultarCotizacionMoneda`. `cotizacion` es `null` si ARCA no tiene
      * cotización para la moneda en esa fecha (responde sin valor y sin error).
      */
     async consultarCotizacionMoneda(auth, codigoMoneda, fechaCotizacion, opts) {
-        const params = validated((f) => ({
-            codigoMoneda: f.text('codigoMoneda', codigoMoneda, true, 3),
-            fechaCotizacion: f.date('fechaCotizacion', fechaCotizacion, true),
-        }));
-        const result = await this.consulta('consultarCotizacionMoneda', auth, params, opts);
-        const r = new ResponseReader('consultarCotizacionMoneda', 'consulta');
+        const method = 'consultarCotizacionMoneda';
+        const params = encodeRequest({ codigoMoneda, fechaCotizacion }, COTIZACION, method);
+        const result = await this.consulta(method, auth, params, opts);
+        const { cotizacionMoneda } = decode(result, COTIZACION_RESPONSE, method, 'consulta');
         return {
-            codigoMoneda: params.codigoMoneda,
-            fechaCotizacion: params.fechaCotizacion,
-            cotizacion: r.optNum(result, 'cotizacionMoneda') ?? null,
+            codigoMoneda: params['codigoMoneda'],
+            fechaCotizacion: params['fechaCotizacion'],
+            cotizacion: cotizacionMoneda ?? null,
         };
     }
-    async puntosVenta(method, auth, opts) {
-        const result = await this.consulta(method, auth, {}, opts);
-        const r = new ResponseReader(method, 'consulta');
-        return this.parsePuntosVenta(r, r.requiredList(result, 'arrayPuntosVenta', 'puntoVenta'));
+    /** `ArrayPuntosVentaType` (obligatorio salvo en `consultarPtosVtaCAEANoInformados`). */
+    parsePuntosVenta(result, method, obligatorio = false) {
+        if (obligatorio)
+            requerido(result, 'arrayPuntosVenta', method, 'consulta');
+        return decode(result, PUNTOS_VENTA_RESPONSE, method, 'consulta')
+            .arrayPuntosVenta;
     }
-    parsePuntosVenta(r, list) {
-        return list.map((pv, i) => ({
-            numeroPuntoVenta: r.num(pv, 'numeroPuntoVenta', `puntoVenta[${i}].numeroPuntoVenta`),
-            bloqueado: r.str(pv, 'bloqueado', `puntoVenta[${i}].bloqueado`),
-            fechaBaja: r.optStr(pv, 'fechaBaja'),
-        }));
+    async puntosVenta(method, auth, opts) {
+        return this.parsePuntosVenta(await this.consulta(method, auth, {}, opts), method, true);
     }
     consultarPuntosVenta(auth, opts) {
         return this.puntosVenta('consultarPuntosVenta', auth, opts);
@@ -360,107 +340,10 @@ export class MtxcaClient {
     }
     /** `consultarActividadesVigentes`: actividades vigentes del emisor. */
     async consultarActividadesVigentes(auth, opts) {
-        const result = await this.consulta('consultarActividadesVigentes', auth, {}, opts);
-        const r = new ResponseReader('consultarActividadesVigentes', 'consulta');
-        return r.list(result['arrayActividades'], 'actividad').map((a, i) => ({
-            codigo: r.num(a, 'codigo', `arrayActividades[${i}].codigo`),
-            orden: r.num(a, 'orden', `arrayActividades[${i}].orden`),
-            descripcion: r.str(a, 'descripcion', `arrayActividades[${i}].descripcion`),
-        }));
+        const method = 'consultarActividadesVigentes';
+        const result = await this.consulta(method, auth, {}, opts);
+        return decode(result, ACTIVIDADES_VIGENTES_RESPONSE, method, 'consulta')
+            .arrayActividades;
     }
 }
-/** Parsea un `ComprobanteType` de `consultarComprobante`. */
-function parseComprobante(r, c) {
-    const periodo = r.optObj(c, 'periodoComprobantesAsociados');
-    return {
-        codigoTipoComprobante: r.num(c, 'codigoTipoComprobante', 'comprobante.codigoTipoComprobante'),
-        numeroPuntoVenta: r.num(c, 'numeroPuntoVenta', 'comprobante.numeroPuntoVenta'),
-        numeroComprobante: r.num(c, 'numeroComprobante', 'comprobante.numeroComprobante'),
-        fechaEmision: r.optStr(c, 'fechaEmision'),
-        codigoTipoAutorizacion: r.optStr(c, 'codigoTipoAutorizacion'),
-        codigoAutorizacion: r.optStr(c, 'codigoAutorizacion'),
-        fechaVencimiento: r.optStr(c, 'fechaVencimiento'),
-        codigoTipoDocumento: r.optNum(c, 'codigoTipoDocumento'),
-        numeroDocumento: r.optStr(c, 'numeroDocumento'),
-        condicionIVAReceptor: r.optNum(c, 'condicionIVAReceptor'),
-        importeGravado: r.optNum(c, 'importeGravado'),
-        importeNoGravado: r.optNum(c, 'importeNoGravado'),
-        importeExento: r.optNum(c, 'importeExento'),
-        importeSubtotal: r.num(c, 'importeSubtotal', 'comprobante.importeSubtotal'),
-        importeOtrosTributos: r.optNum(c, 'importeOtrosTributos'),
-        importeTotal: r.num(c, 'importeTotal', 'comprobante.importeTotal'),
-        codigoMoneda: r.str(c, 'codigoMoneda', 'comprobante.codigoMoneda'),
-        cotizacionMoneda: r.optNum(c, 'cotizacionMoneda'),
-        cancelaEnMismaMonedaExtranjera: r.optStr(c, 'cancelaEnMismaMonedaExtranjera'),
-        observaciones: r.optStr(c, 'observaciones'),
-        codigoConcepto: r.num(c, 'codigoConcepto', 'comprobante.codigoConcepto'),
-        fechaServicioDesde: r.optStr(c, 'fechaServicioDesde'),
-        fechaServicioHasta: r.optStr(c, 'fechaServicioHasta'),
-        fechaVencimientoPago: r.optStr(c, 'fechaVencimientoPago'),
-        fechaHoraGen: r.optStr(c, 'fechaHoraGen'),
-        comprobantesAsociados: r.list(c['arrayComprobantesAsociados'], 'comprobanteAsociado').map((a, i) => {
-            const p = `comprobante.arrayComprobantesAsociados[${i}]`;
-            return {
-                codigoTipoComprobante: r.num(a, 'codigoTipoComprobante', `${p}.codigoTipoComprobante`),
-                numeroPuntoVenta: r.num(a, 'numeroPuntoVenta', `${p}.numeroPuntoVenta`),
-                numeroComprobante: r.num(a, 'numeroComprobante', `${p}.numeroComprobante`),
-                cuit: r.optStr(a, 'cuit'),
-                fechaEmision: r.optStr(a, 'fechaEmision'),
-            };
-        }),
-        periodoComprobantesAsociados: periodo
-            ? {
-                fechaDesde: r.str(periodo, 'fechaDesde', 'comprobante.periodoComprobantesAsociados.fechaDesde'),
-                fechaHasta: r.str(periodo, 'fechaHasta', 'comprobante.periodoComprobantesAsociados.fechaHasta'),
-            }
-            : undefined,
-        otrosTributos: r.list(c['arrayOtrosTributos'], 'otroTributo').map((t, i) => {
-            const p = `comprobante.arrayOtrosTributos[${i}]`;
-            return {
-                codigo: r.num(t, 'codigo', `${p}.codigo`),
-                descripcion: r.optStr(t, 'descripcion'),
-                baseImponible: r.num(t, 'baseImponible', `${p}.baseImponible`),
-                importe: r.num(t, 'importe', `${p}.importe`),
-            };
-        }),
-        items: r.requiredList(c, 'arrayItems', 'item').map((it, i) => {
-            const p = `comprobante.arrayItems[${i}]`;
-            return {
-                unidadesMtx: r.optNum(it, 'unidadesMtx'),
-                codigoMtx: r.optStr(it, 'codigoMtx'),
-                codigo: r.optStr(it, 'codigo'),
-                descripcion: r.str(it, 'descripcion', `${p}.descripcion`),
-                cantidad: r.optNum(it, 'cantidad'),
-                codigoUnidadMedida: r.num(it, 'codigoUnidadMedida', `${p}.codigoUnidadMedida`),
-                precioUnitario: r.optNum(it, 'precioUnitario'),
-                importeBonificacion: r.optNum(it, 'importeBonificacion'),
-                codigoCondicionIVA: r.num(it, 'codigoCondicionIVA', `${p}.codigoCondicionIVA`),
-                importeIVA: r.optNum(it, 'importeIVA'),
-                importeItem: r.num(it, 'importeItem', `${p}.importeItem`),
-            };
-        }),
-        subtotalesIVA: r.list(c['arraySubtotalesIVA'], 'subtotalIVA').map((s, i) => ({
-            codigo: r.num(s, 'codigo', `comprobante.arraySubtotalesIVA[${i}].codigo`),
-            importe: r.num(s, 'importe', `comprobante.arraySubtotalesIVA[${i}].importe`),
-        })),
-        datosAdicionales: r.list(c['arrayDatosAdicionales'], 'datoAdicional').map((d, i) => ({
-            t: r.num(d, 't', `comprobante.arrayDatosAdicionales[${i}].t`),
-            c1: r.optStr(d, 'c1'),
-            c2: r.optStr(d, 'c2'),
-            c3: r.optStr(d, 'c3'),
-            c4: r.optStr(d, 'c4'),
-            c5: r.optStr(d, 'c5'),
-            c6: r.optStr(d, 'c6'),
-        })),
-        compradores: r.list(c['arrayCompradores'], 'comprador').map((x, i) => {
-            const p = `comprobante.arrayCompradores[${i}]`;
-            return {
-                codigoTipoDocumento: r.num(x, 'codigoTipoDocumento', `${p}.codigoTipoDocumento`),
-                numeroDocumento: r.str(x, 'numeroDocumento', `${p}.numeroDocumento`),
-                porcentaje: r.num(x, 'porcentaje', `${p}.porcentaje`),
-            };
-        }),
-        actividades: r.list(c['arrayActividades'], 'actividad').map((a, i) => r.num(a, 'codigo', `comprobante.arrayActividades[${i}].codigo`)),
-    };
-}
 //# sourceMappingURL=mtxca-client.js.map