arca-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,725 @@
+// src/constants/endpoints.ts
+var WSAA_ENDPOINTS = {
+  homologacion: "https://wsaahomo.afip.gov.ar/ws/services/LoginCms",
+  produccion: "https://wsaa.afip.gov.ar/ws/services/LoginCms"
+};
+var WSFE_ENDPOINTS = {
+  homologacion: "https://wswhomo.afip.gov.ar/wsfev1/service.asmx",
+  produccion: "https://servicios1.afip.gov.ar/wsfev1/service.asmx"
+};
+function getWsaaEndpoint(environment) {
+  return WSAA_ENDPOINTS[environment];
+}
+function getWsfeEndpoint(environment) {
+  return WSFE_ENDPOINTS[environment];
+}
+
+// src/types/common.ts
+var ArcaError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ArcaError";
+  }
+};
+var ArcaAuthError = class extends ArcaError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", details);
+    this.name = "ArcaAuthError";
+  }
+};
+var ArcaValidationError = class extends ArcaError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "ArcaValidationError";
+  }
+};
+
+// src/utils/xml.ts
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+function buildTRA(service, cuit) {
+  const now = /* @__PURE__ */ new Date();
+  const expirationTime = new Date(now.getTime() + 12 * 60 * 60 * 1e3);
+  const tra = {
+    loginTicketRequest: {
+      "@_version": "1.0",
+      header: {
+        uniqueId: Math.floor(now.getTime() / 1e3),
+        generationTime: now.toISOString(),
+        expirationTime: expirationTime.toISOString()
+      },
+      service
+    }
+  };
+  const builder = new XMLBuilder({
+    ignoreAttributes: false,
+    format: true
+  });
+  const xml = builder.build(tra);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+${xml}`;
+}
+function parseWsaaResponse(xml) {
+  try {
+    const parser = new XMLParser({
+      ignoreAttributes: false,
+      parseAttributeValue: true,
+      removeNSPrefix: true
+      // Sugerencia: más robusto contra cambios de prefijos soapenv
+    });
+    const result = parser.parse(xml);
+    const credentials = result?.Envelope?.Body?.loginCmsResponse?.loginCmsReturn;
+    if (!credentials) {
+      const fault = result?.Envelope?.Body?.Fault;
+      if (fault) {
+        throw new ArcaAuthError(
+          `Error ARCA: ${fault.faultstring || "Error desconocido"}`,
+          { faultCode: fault.faultcode, detail: fault.detail }
+        );
+      }
+      throw new ArcaAuthError(
+        "Respuesta WSAA inv\xE1lida: estructura no reconocida",
+        { receivedStructure: result }
+      );
+    }
+    return {
+      token: credentials.token,
+      sign: credentials.sign,
+      generationTime: new Date(credentials.header.generationTime),
+      expirationTime: new Date(credentials.header.expirationTime)
+    };
+  } catch (error) {
+    if (error instanceof ArcaAuthError) throw error;
+    throw new ArcaAuthError(
+      "Error al parsear respuesta WSAA",
+      { originalError: error }
+    );
+  }
+}
+function parseXml(xml) {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    parseAttributeValue: true,
+    removeNSPrefix: true
+  });
+  return parser.parse(xml);
+}
+function validateCUIT(cuit) {
+  return /^\d{11}$/.test(cuit);
+}
+
+// src/utils/crypto.ts
+import * as forge from "node-forge";
+function signCMS(xml, certPem, keyPem) {
+  try {
+    const cert = forge.pki.certificateFromPem(certPem);
+    const privateKey = forge.pki.privateKeyFromPem(keyPem);
+    const p7 = forge.pkcs7.createSignedData();
+    p7.content = forge.util.createBuffer(xml, "utf8");
+    p7.addCertificate(cert);
+    p7.addSigner({
+      key: privateKey,
+      certificate: cert,
+      digestAlgorithm: forge.pki.oids.sha256,
+      authenticatedAttributes: [
+        {
+          type: forge.pki.oids.contentType,
+          value: forge.pki.oids.data
+        },
+        {
+          type: forge.pki.oids.messageDigest
+          // El valor será calculado automáticamente
+        },
+        {
+          type: forge.pki.oids.signingTime,
+          // node-forge expects a Date object, but its typings might be missing or expect string/any
+          value: /* @__PURE__ */ new Date()
+        }
+      ]
+    });
+    p7.sign();
+    const derBytes = forge.asn1.toDer(p7.toAsn1()).getBytes();
+    const base64 = forge.util.encode64(derBytes);
+    return base64;
+  } catch (error) {
+    if (error instanceof ArcaAuthError) throw error;
+    throw new ArcaAuthError(
+      "Error al firmar XML con certificado usando PKCS#7",
+      {
+        originalError: error,
+        hint: "Verificar que el certificado y la clave privada sean v\xE1lidos y correspondan entre s\xED"
+      }
+    );
+  }
+}
+function validateCertificate(cert) {
+  return cert.includes("-----BEGIN CERTIFICATE-----") && cert.includes("-----END CERTIFICATE-----");
+}
+function validatePrivateKey(key) {
+  return key.includes("-----BEGIN PRIVATE KEY-----") && key.includes("-----END PRIVATE KEY-----") || key.includes("-----BEGIN RSA PRIVATE KEY-----") && key.includes("-----END RSA PRIVATE KEY-----");
+}
+
+// src/auth/ticket.ts
+var TicketManager = class {
+  ticket = null;
+  /**
+   * Guarda un ticket en cache
+   */
+  setTicket(ticket) {
+    this.ticket = ticket;
+  }
+  /**
+   * Obtiene el ticket actual si es válido
+   * @returns Ticket válido o null si expiró
+   */
+  getTicket() {
+    if (!this.ticket) return null;
+    const now = /* @__PURE__ */ new Date();
+    const expiresIn = this.ticket.expirationTime.getTime() - now.getTime();
+    const BUFFER_MS = 5 * 60 * 1e3;
+    if (expiresIn < BUFFER_MS) {
+      this.ticket = null;
+      return null;
+    }
+    return this.ticket;
+  }
+  /**
+   * Verifica si hay un ticket válido
+   */
+  hasValidTicket() {
+    return this.getTicket() !== null;
+  }
+  /**
+   * Limpia el ticket en cache
+   */
+  clearTicket() {
+    this.ticket = null;
+  }
+};
+
+// src/auth/wsaa.ts
+var WsaaService = class {
+  config;
+  ticketManager;
+  constructor(config) {
+    this.validateConfig(config);
+    this.config = config;
+    this.ticketManager = new TicketManager();
+  }
+  /**
+   * Valida la configuración
+   */
+  validateConfig(config) {
+    if (!validateCUIT(config.cuit)) {
+      throw new ArcaValidationError(
+        "CUIT inv\xE1lido: debe tener 11 d\xEDgitos sin guiones",
+        { cuit: config.cuit }
+      );
+    }
+    if (!validateCertificate(config.cert)) {
+      throw new ArcaValidationError(
+        "Certificado inv\xE1lido: debe estar en formato PEM",
+        { hint: "Debe contener -----BEGIN CERTIFICATE-----" }
+      );
+    }
+    if (!validatePrivateKey(config.key)) {
+      throw new ArcaValidationError(
+        "Clave privada inv\xE1lida: debe estar en formato PEM",
+        { hint: "Debe contener -----BEGIN PRIVATE KEY----- o -----BEGIN RSA PRIVATE KEY-----" }
+      );
+    }
+    if (!config.service || config.service.trim() === "") {
+      throw new ArcaValidationError(
+        "Servicio ARCA no especificado",
+        { hint: 'Ejemplos: "wsfe", "wsmtxca"' }
+      );
+    }
+  }
+  /**
+   * Obtiene un ticket de acceso válido
+   * Usa cache si el ticket actual es válido
+   * 
+   * @returns Ticket de acceso
+   */
+  async login() {
+    const cachedTicket = this.ticketManager.getTicket();
+    if (cachedTicket) {
+      return cachedTicket;
+    }
+    const ticket = await this.requestNewTicket();
+    this.ticketManager.setTicket(ticket);
+    return ticket;
+  }
+  /**
+   * Solicita un nuevo ticket a WSAA
+   */
+  async requestNewTicket() {
+    const tra = buildTRA(this.config.service, this.config.cuit);
+    let cms;
+    try {
+      cms = signCMS(tra, this.config.cert, this.config.key);
+    } catch (error) {
+      throw new ArcaAuthError(
+        "Error al firmar TRA con certificado",
+        { originalError: error }
+      );
+    }
+    const endpoint = getWsaaEndpoint(this.config.environment);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": ""
+      },
+      body: this.buildSoapRequest(cms)
+    });
+    if (!response.ok) {
+      throw new ArcaAuthError(
+        `Error HTTP al comunicarse con WSAA: ${response.status} ${response.statusText}`,
+        { status: response.status, statusText: response.statusText }
+      );
+    }
+    const responseXml = await response.text();
+    return parseWsaaResponse(responseXml);
+  }
+  /**
+   * Construye el SOAP request para WSAA
+   */
+  buildSoapRequest(cms) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
+                  xmlns:wsaa="http://wsaa.view.sua.dvadac.desein.afip.gov">
+  <soapenv:Header/>
+  <soapenv:Body>
+    <wsaa:loginCms>
+      <wsaa:in0>${cms}</wsaa:in0>
+    </wsaa:loginCms>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+  }
+  /**
+   * Limpia el ticket en cache (forzar renovación)
+   */
+  clearCache() {
+    this.ticketManager.clearTicket();
+  }
+};
+
+// src/types/wsfe.ts
+var TipoComprobante = /* @__PURE__ */ ((TipoComprobante2) => {
+  TipoComprobante2[TipoComprobante2["FACTURA_A"] = 1] = "FACTURA_A";
+  TipoComprobante2[TipoComprobante2["FACTURA_B"] = 6] = "FACTURA_B";
+  TipoComprobante2[TipoComprobante2["FACTURA_C"] = 11] = "FACTURA_C";
+  TipoComprobante2[TipoComprobante2["TICKET_A"] = 81] = "TICKET_A";
+  TipoComprobante2[TipoComprobante2["TICKET_B"] = 82] = "TICKET_B";
+  TipoComprobante2[TipoComprobante2["TICKET_C"] = 83] = "TICKET_C";
+  return TipoComprobante2;
+})(TipoComprobante || {});
+var Concepto = /* @__PURE__ */ ((Concepto2) => {
+  Concepto2[Concepto2["PRODUCTOS"] = 1] = "PRODUCTOS";
+  Concepto2[Concepto2["SERVICIOS"] = 2] = "SERVICIOS";
+  Concepto2[Concepto2["PRODUCTOS_Y_SERVICIOS"] = 3] = "PRODUCTOS_Y_SERVICIOS";
+  return Concepto2;
+})(Concepto || {});
+var TipoDocumento = /* @__PURE__ */ ((TipoDocumento2) => {
+  TipoDocumento2[TipoDocumento2["CUIT"] = 80] = "CUIT";
+  TipoDocumento2[TipoDocumento2["CUIL"] = 86] = "CUIL";
+  TipoDocumento2[TipoDocumento2["CDI"] = 87] = "CDI";
+  TipoDocumento2[TipoDocumento2["LE"] = 89] = "LE";
+  TipoDocumento2[TipoDocumento2["LC"] = 90] = "LC";
+  TipoDocumento2[TipoDocumento2["CI_EXTRANJERA"] = 91] = "CI_EXTRANJERA";
+  TipoDocumento2[TipoDocumento2["PASAPORTE"] = 94] = "PASAPORTE";
+  TipoDocumento2[TipoDocumento2["CI_BUENOS_AIRES"] = 95] = "CI_BUENOS_AIRES";
+  TipoDocumento2[TipoDocumento2["CI_POLICIA_FEDERAL"] = 96] = "CI_POLICIA_FEDERAL";
+  TipoDocumento2[TipoDocumento2["DNI"] = 96] = "DNI";
+  TipoDocumento2[TipoDocumento2["CONSUMIDOR_FINAL"] = 99] = "CONSUMIDOR_FINAL";
+  return TipoDocumento2;
+})(TipoDocumento || {});
+
+// src/utils/calculations.ts
+function calcularSubtotal(items) {
+  return items.reduce((sum, item) => {
+    return sum + item.cantidad * item.precioUnitario;
+  }, 0);
+}
+function calcularIVA(items) {
+  return items.reduce((sum, item) => {
+    const subtotal = item.cantidad * item.precioUnitario;
+    const alicuota = item.alicuotaIva || 0;
+    return sum + subtotal * alicuota / 100;
+  }, 0);
+}
+function calcularTotal(items) {
+  const subtotal = calcularSubtotal(items);
+  const iva = calcularIVA(items);
+  return subtotal + iva;
+}
+function redondear(valor) {
+  return Math.round(valor * 100) / 100;
+}
+
+// src/services/wsfe.ts
+var WsfeService = class {
+  config;
+  constructor(config) {
+    this.validateConfig(config);
+    this.config = config;
+  }
+  validateConfig(config) {
+    if (!config.ticket || !config.ticket.token) {
+      throw new ArcaValidationError(
+        "Ticket WSAA requerido. Ejecut\xE1 wsaa.login() primero.",
+        { hint: "El ticket se obtiene del servicio WSAA" }
+      );
+    }
+    if (!config.puntoVenta || config.puntoVenta < 1 || config.puntoVenta > 9999) {
+      throw new ArcaValidationError(
+        "Punto de venta inv\xE1lido: debe ser un n\xFAmero entre 1 y 9999",
+        { puntoVenta: config.puntoVenta }
+      );
+    }
+  }
+  /**
+   * Emite un Ticket C de forma simple (solo total)
+   * Tipo de comprobante: 83
+   */
+  async emitirTicketCSimple(params) {
+    return this.emitirComprobante({
+      tipo: 83 /* TICKET_C */,
+      concepto: params.concepto || 1 /* PRODUCTOS */,
+      total: params.total,
+      fecha: params.fecha,
+      comprador: {
+        tipoDocumento: 99 /* CONSUMIDOR_FINAL */,
+        nroDocumento: "0"
+      }
+    });
+  }
+  /**
+   * Emite un Ticket C completo (con detalle de items)
+   * Los items no se envían a ARCA, pero se retornan en la respuesta.
+   */
+  async emitirTicketC(params) {
+    const total = redondear(calcularTotal(params.items));
+    const cae = await this.emitirComprobante({
+      tipo: 83 /* TICKET_C */,
+      concepto: params.concepto || 1 /* PRODUCTOS */,
+      total,
+      fecha: params.fecha,
+      comprador: {
+        tipoDocumento: 99 /* CONSUMIDOR_FINAL */,
+        nroDocumento: "0"
+      }
+    });
+    return {
+      ...cae,
+      items: params.items
+    };
+  }
+  /**
+   * Emite una Factura B (monotributo a responsable inscripto)
+   * REQUIERE detalle de items con IVA discriminado
+   */
+  async emitirFacturaB(params) {
+    this.validateItemsWithIVA(params.items);
+    const ivaData = this.calcularIVAPorAlicuota(params.items);
+    return this.emitirComprobante({
+      tipo: 6 /* FACTURA_B */,
+      concepto: params.concepto || 1 /* PRODUCTOS */,
+      items: params.items,
+      comprador: params.comprador,
+      fecha: params.fecha,
+      ivaData
+    });
+  }
+  /**
+   * Emite una Factura A (RI a RI)
+   * REQUIERE detalle de items con IVA discriminado
+   */
+  async emitirFacturaA(params) {
+    this.validateItemsWithIVA(params.items);
+    const ivaData = this.calcularIVAPorAlicuota(params.items);
+    return this.emitirComprobante({
+      tipo: 1 /* FACTURA_A */,
+      concepto: params.concepto || 1 /* PRODUCTOS */,
+      items: params.items,
+      comprador: params.comprador,
+      fecha: params.fecha,
+      ivaData
+    });
+  }
+  /**
+   * Valida que todos los items tengan alícuota IVA definida
+   */
+  validateItemsWithIVA(items) {
+    const sinIva = items.filter(
+      (item) => item.alicuotaIva === void 0 || item.alicuotaIva === null
+    );
+    if (sinIva.length > 0) {
+      throw new ArcaValidationError(
+        "Esta operaci\xF3n requiere IVA discriminado en todos los items",
+        {
+          itemsSinIva: sinIva.map((i) => i.descripcion),
+          hint: "Agreg\xE1 alicuotaIva a cada item (21, 10.5, 27, o 0)"
+        }
+      );
+    }
+  }
+  /**
+   * Calcula IVA agrupado por alícuota
+   * ARCA requiere esto para Factura B/A
+   */
+  calcularIVAPorAlicuota(items) {
+    const porAlicuota = /* @__PURE__ */ new Map();
+    items.forEach((item) => {
+      const alicuota = item.alicuotaIva || 0;
+      const base = item.cantidad * item.precioUnitario;
+      const importe = base * alicuota / 100;
+      const actual = porAlicuota.get(alicuota) || { base: 0, importe: 0 };
+      porAlicuota.set(alicuota, {
+        base: actual.base + base,
+        importe: actual.importe + importe
+      });
+    });
+    return Array.from(porAlicuota.entries()).map(([alicuota, valores]) => ({
+      alicuota,
+      baseImponible: redondear(valores.base),
+      importe: redondear(valores.importe)
+    }));
+  }
+  /**
+   * Emite una Factura C (consumidor final)
+   * Forma simplificada sin especificar comprador
+   */
+  async emitirFacturaC(params) {
+    const total = redondear(calcularTotal(params.items));
+    return this.emitirComprobante({
+      tipo: 11 /* FACTURA_C */,
+      concepto: params.concepto || 1 /* PRODUCTOS */,
+      total,
+      fecha: params.fecha,
+      comprador: {
+        tipoDocumento: 99 /* CONSUMIDOR_FINAL */,
+        nroDocumento: "0"
+      },
+      items: params.items
+    });
+  }
+  /**
+   * Emite un comprobante (método genérico interno)
+   */
+  async emitirComprobante(request) {
+    const nroComprobante = await this.obtenerProximoNumero(request.tipo);
+    let total = request.total || 0;
+    let subtotal = total;
+    let iva = 0;
+    if (request.items && request.items.length > 0) {
+      subtotal = redondear(calcularSubtotal(request.items));
+      iva = redondear(calcularIVA(request.items));
+      total = redondear(calcularTotal(request.items));
+    }
+    if (total <= 0) {
+      throw new ArcaValidationError("El monto total debe ser mayor a 0");
+    }
+    const soapRequest = this.buildCAESolicitarRequest({
+      tipo: request.tipo,
+      puntoVenta: this.config.puntoVenta,
+      nroComprobante,
+      concepto: request.concepto,
+      fecha: request.fecha || /* @__PURE__ */ new Date(),
+      comprador: request.comprador,
+      subtotal,
+      iva,
+      total,
+      ivaData: request.ivaData
+    });
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECAESolicitar"
+      },
+      body: soapRequest
+    });
+    if (!response.ok) {
+      throw new ArcaError(
+        `Error HTTP al comunicarse con WSFE: ${response.status}`,
+        "HTTP_ERROR",
+        { status: response.status }
+      );
+    }
+    const responseXml = await response.text();
+    const result = await this.parseCAEResponse(responseXml);
+    return {
+      ...result,
+      items: request.items,
+      iva: request.ivaData
+    };
+  }
+  /**
+   * Obtiene el próximo número de comprobante disponible
+   */
+  async obtenerProximoNumero(tipo) {
+    const soapRequest = this.buildProximoNumeroRequest(tipo);
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECompUltimoAutorizado"
+      },
+      body: soapRequest
+    });
+    if (!response.ok) {
+      throw new ArcaError(`Error HTTP al consultar pr\xF3ximo n\xFAmero: ${response.status}`, "HTTP_ERROR");
+    }
+    const responseXml = await response.text();
+    const result = parseXml(responseXml);
+    const data = result?.Envelope?.Body?.FECompUltimoAutorizadoResponse?.FECompUltimoAutorizadoResult;
+    if (data?.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      throw new ArcaError(`Error ARCA: ${error?.Msg || "Error desconocido"}`, "ARCA_ERROR", data.Errors);
+    }
+    const nro = data?.CbteNro;
+    return typeof nro === "number" ? nro + 1 : 1;
+  }
+  buildCAESolicitarRequest(params) {
+    const fechaStr = params.fecha.toISOString().split("T")[0].replace(/-/g, "");
+    let ivaXml = "";
+    if (params.ivaData && params.ivaData.length > 0) {
+      ivaXml = "<ar:Iva>";
+      params.ivaData.forEach((aliquot) => {
+        ivaXml += `
+        <ar:AlicIva>
+          <ar:Id>${this.getCodigoAlicuota(aliquot.alicuota)}</ar:Id>
+          <ar:BaseImp>${aliquot.baseImponible.toFixed(2)}</ar:BaseImp>
+          <ar:Importe>${aliquot.importe.toFixed(2)}</ar:Importe>
+        </ar:AlicIva>`;
+      });
+      ivaXml += "\n      </ar:Iva>";
+    }
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
+                  xmlns:ar="http://ar.gov.afip.dif.FEV1/">
+  <soapenv:Header/>
+  <soapenv:Body>
+    <ar:FECAESolicitar>
+      <ar:Auth>
+        <ar:Token>${this.config.ticket.token}</ar:Token>
+        <ar:Sign>${this.config.ticket.sign}</ar:Sign>
+        <ar:Cuit>${this.config.cuit}</ar:Cuit>
+      </ar:Auth>
+      <ar:FeCAEReq>
+        <ar:FeCabReq>
+          <ar:CantReg>1</ar:CantReg>
+          <ar:PtoVta>${params.puntoVenta}</ar:PtoVta>
+          <ar:CbteTipo>${params.tipo}</ar:CbteTipo>
+        </ar:FeCabReq>
+        <ar:FeDetReq>
+          <ar:FECAEDetRequest>
+            <ar:Concepto>${params.concepto}</ar:Concepto>
+            <ar:DocTipo>${params.comprador?.tipoDocumento || 99}</ar:DocTipo>
+            <ar:DocNro>${params.comprador?.nroDocumento || 0}</ar:DocNro>
+            <ar:CbteDesde>${params.nroComprobante}</ar:CbteDesde>
+            <ar:CbteHasta>${params.nroComprobante}</ar:CbteHasta>
+            <ar:CbteFch>${fechaStr}</ar:CbteFch>
+            <ar:ImpTotal>${params.total.toFixed(2)}</ar:ImpTotal>
+            <ar:ImpTotConc>0.00</ar:ImpTotConc>
+            <ar:ImpNeto>${params.subtotal.toFixed(2)}</ar:ImpNeto>
+            <ar:ImpOpEx>0.00</ar:ImpOpEx>
+            <ar:ImpIVA>${params.iva.toFixed(2)}</ar:ImpIVA>
+            <ar:ImpTrib>0.00</ar:ImpTrib>
+            <ar:MonId>PES</ar:MonId>
+            <ar:MonCotiz>1</ar:MonCotiz>
+            ${ivaXml}
+          </ar:FECAEDetRequest>
+        </ar:FeDetReq>
+      </ar:FeCAEReq>
+    </ar:FECAESolicitar>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+  }
+  /**
+   * Mapea alícuota % a código ARCA
+   */
+  getCodigoAlicuota(porcentaje) {
+    const mapa = {
+      0: 3,
+      10.5: 4,
+      21: 5,
+      27: 6
+    };
+    const codigo = mapa[porcentaje];
+    if (!codigo) {
+      throw new ArcaValidationError(
+        `Al\xEDcuota IVA inv\xE1lida: ${porcentaje}%`,
+        {
+          alicuotasValidas: [0, 10.5, 21, 27],
+          hint: "Usar una de las al\xEDcuotas oficiales de Argentina"
+        }
+      );
+    }
+    return codigo;
+  }
+  buildProximoNumeroRequest(tipo) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
+                  xmlns:ar="http://ar.gov.afip.dif.FEV1/">
+  <soapenv:Header/>
+  <soapenv:Body>
+    <ar:FECompUltimoAutorizado>
+      <ar:Auth>
+        <ar:Token>${this.config.ticket.token}</ar:Token>
+        <ar:Sign>${this.config.ticket.sign}</ar:Sign>
+        <ar:Cuit>${this.config.cuit}</ar:Cuit>
+      </ar:Auth>
+      <ar:PtoVta>${this.config.puntoVenta}</ar:PtoVta>
+      <ar:CbteTipo>${tipo}</ar:CbteTipo>
+    </ar:FECompUltimoAutorizado>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+  }
+  async parseCAEResponse(xml) {
+    const result = parseXml(xml);
+    const data = result?.Envelope?.Body?.FECAESolicitarResponse?.FECAESolicitarResult;
+    if (!data) {
+      throw new ArcaError("Respuesta WSFE inv\xE1lida: estructura no reconocida", "PARSE_ERROR", { xml });
+    }
+    if (data.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      throw new ArcaError(`Error ARCA: ${error?.Msg || "Error desconocido"}`, "ARCA_ERROR", data.Errors);
+    }
+    const cab = data.FeCabResp;
+    const det = Array.isArray(data.FeDetResp.FECAEDetResponse) ? data.FeDetResp.FECAEDetResponse[0] : data.FeDetResp.FECAEDetResponse;
+    if (!det) {
+      throw new ArcaError("Respuesta WSFE incompleta: falta detalle del comprobante", "PARSE_ERROR");
+    }
+    const observaciones = [];
+    if (det.Observaciones) {
+      const obsArray = Array.isArray(det.Observaciones.Obs) ? det.Observaciones.Obs : [det.Observaciones.Obs];
+      obsArray.forEach((o) => observaciones.push(o.Msg));
+    }
+    return {
+      tipoComprobante: cab.CbteTipo,
+      puntoVenta: cab.PtoVta,
+      nroComprobante: det.CbteDesde,
+      fecha: det.CbteFch,
+      cae: det.CAE,
+      vencimientoCae: det.CAEFchVto,
+      resultado: det.Resultado,
+      observaciones: observaciones.length > 0 ? observaciones : void 0
+    };
+  }
+};
+export {
+  ArcaAuthError,
+  ArcaError,
+  ArcaValidationError,
+  Concepto,
+  TipoComprobante,
+  TipoDocumento,
+  WsaaService,
+  WsfeService
+};