arca-sdk 1.2.2 → 1.3.1

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   ArcaNetworkError: () => ArcaNetworkError,
   ArcaValidationError: () => ArcaValidationError,
   BillingConcept: () => BillingConcept,
+  CaeaService: () => CaeaService,
   InvoiceType: () => InvoiceType,
   PadronService: () => PadronService,
   TaxIdType: () => TaxIdType,
@@ -385,6 +386,7 @@ async function callArcaApi(url, options) {
 }
 
 // src/auth/wsaa.ts
+var import_fast_xml_parser2 = require("fast-xml-parser");
 var WsaaService = class {
   config;
   ticketManager;
@@ -486,13 +488,27 @@ var WsaaService = class {
       body: this.buildSoapRequest(cms),
       timeout: this.config.timeout
     });
+    const responseText = await response.text();
     if (!response.ok) {
+      let errorMessage = `Error HTTP al comunicarse con WSAA: ${response.status} ${response.statusText}`;
+      try {
+        const parser = new import_fast_xml_parser2.XMLParser({
+          ignoreAttributes: false,
+          removeNSPrefix: true
+        });
+        const result = parser.parse(responseText);
+        const fault = result.Envelope?.Body?.Fault;
+        if (fault && fault.faultstring) {
+          errorMessage = `Error AFIP WSAA: ${fault.faultstring}`;
+        }
+      } catch (e) {
+      }
       throw new ArcaAuthError(
-        `Error HTTP al comunicarse con WSAA: ${response.status} ${response.statusText}`,
-        { status: response.status, statusText: response.statusText }
+        errorMessage,
+        { status: response.status, statusText: response.statusText, body: responseText }
       );
     }
-    const responseXml = await response.text();
+    const responseXml = responseText;
     return parseWsaaResponse(responseXml);
   }
   /**
@@ -519,23 +535,23 @@ var WsaaService = class {
 };
 
 // src/types/wsfe.ts
-var InvoiceType = /* @__PURE__ */ ((InvoiceType2) => {
-  InvoiceType2[InvoiceType2["FACTURA_A"] = 1] = "FACTURA_A";
-  InvoiceType2[InvoiceType2["NOTA_DEBITO_A"] = 2] = "NOTA_DEBITO_A";
-  InvoiceType2[InvoiceType2["NOTA_CREDITO_A"] = 3] = "NOTA_CREDITO_A";
-  InvoiceType2[InvoiceType2["RECIBO_A"] = 4] = "RECIBO_A";
-  InvoiceType2[InvoiceType2["FACTURA_B"] = 6] = "FACTURA_B";
-  InvoiceType2[InvoiceType2["NOTA_DEBITO_B"] = 7] = "NOTA_DEBITO_B";
-  InvoiceType2[InvoiceType2["NOTA_CREDITO_B"] = 8] = "NOTA_CREDITO_B";
-  InvoiceType2[InvoiceType2["RECIBO_B"] = 9] = "RECIBO_B";
-  InvoiceType2[InvoiceType2["FACTURA_C"] = 11] = "FACTURA_C";
-  InvoiceType2[InvoiceType2["NOTA_DEBITO_C"] = 12] = "NOTA_DEBITO_C";
-  InvoiceType2[InvoiceType2["NOTA_CREDITO_C"] = 13] = "NOTA_CREDITO_C";
-  InvoiceType2[InvoiceType2["RECIBO_C"] = 15] = "RECIBO_C";
-  InvoiceType2[InvoiceType2["TICKET_A"] = 81] = "TICKET_A";
-  InvoiceType2[InvoiceType2["TICKET_B"] = 82] = "TICKET_B";
-  InvoiceType2[InvoiceType2["TICKET_C"] = 83] = "TICKET_C";
-  return InvoiceType2;
+var InvoiceType = /* @__PURE__ */ ((InvoiceType3) => {
+  InvoiceType3[InvoiceType3["FACTURA_A"] = 1] = "FACTURA_A";
+  InvoiceType3[InvoiceType3["NOTA_DEBITO_A"] = 2] = "NOTA_DEBITO_A";
+  InvoiceType3[InvoiceType3["NOTA_CREDITO_A"] = 3] = "NOTA_CREDITO_A";
+  InvoiceType3[InvoiceType3["RECIBO_A"] = 4] = "RECIBO_A";
+  InvoiceType3[InvoiceType3["FACTURA_B"] = 6] = "FACTURA_B";
+  InvoiceType3[InvoiceType3["NOTA_DEBITO_B"] = 7] = "NOTA_DEBITO_B";
+  InvoiceType3[InvoiceType3["NOTA_CREDITO_B"] = 8] = "NOTA_CREDITO_B";
+  InvoiceType3[InvoiceType3["RECIBO_B"] = 9] = "RECIBO_B";
+  InvoiceType3[InvoiceType3["FACTURA_C"] = 11] = "FACTURA_C";
+  InvoiceType3[InvoiceType3["NOTA_DEBITO_C"] = 12] = "NOTA_DEBITO_C";
+  InvoiceType3[InvoiceType3["NOTA_CREDITO_C"] = 13] = "NOTA_CREDITO_C";
+  InvoiceType3[InvoiceType3["RECIBO_C"] = 15] = "RECIBO_C";
+  InvoiceType3[InvoiceType3["TICKET_A"] = 81] = "TICKET_A";
+  InvoiceType3[InvoiceType3["TICKET_B"] = 82] = "TICKET_B";
+  InvoiceType3[InvoiceType3["TICKET_C"] = 83] = "TICKET_C";
+  return InvoiceType3;
 })(InvoiceType || {});
 var BillingConcept = /* @__PURE__ */ ((BillingConcept2) => {
   BillingConcept2[BillingConcept2["PRODUCTS"] = 1] = "PRODUCTS";
@@ -543,19 +559,19 @@ var BillingConcept = /* @__PURE__ */ ((BillingConcept2) => {
   BillingConcept2[BillingConcept2["PRODUCTS_AND_SERVICES"] = 3] = "PRODUCTS_AND_SERVICES";
   return BillingConcept2;
 })(BillingConcept || {});
-var TaxIdType = /* @__PURE__ */ ((TaxIdType2) => {
-  TaxIdType2[TaxIdType2["CUIT"] = 80] = "CUIT";
-  TaxIdType2[TaxIdType2["CUIL"] = 86] = "CUIL";
-  TaxIdType2[TaxIdType2["CDI"] = 87] = "CDI";
-  TaxIdType2[TaxIdType2["LE"] = 89] = "LE";
-  TaxIdType2[TaxIdType2["LC"] = 90] = "LC";
-  TaxIdType2[TaxIdType2["FOREIGN_ID"] = 91] = "FOREIGN_ID";
-  TaxIdType2[TaxIdType2["PASSPORT"] = 94] = "PASSPORT";
-  TaxIdType2[TaxIdType2["BUENOS_AIRES_ID"] = 95] = "BUENOS_AIRES_ID";
-  TaxIdType2[TaxIdType2["NATIONAL_POLICE_ID"] = 96] = "NATIONAL_POLICE_ID";
-  TaxIdType2[TaxIdType2["DNI"] = 96] = "DNI";
-  TaxIdType2[TaxIdType2["FINAL_CONSUMER"] = 99] = "FINAL_CONSUMER";
-  return TaxIdType2;
+var TaxIdType = /* @__PURE__ */ ((TaxIdType3) => {
+  TaxIdType3[TaxIdType3["CUIT"] = 80] = "CUIT";
+  TaxIdType3[TaxIdType3["CUIL"] = 86] = "CUIL";
+  TaxIdType3[TaxIdType3["CDI"] = 87] = "CDI";
+  TaxIdType3[TaxIdType3["LE"] = 89] = "LE";
+  TaxIdType3[TaxIdType3["LC"] = 90] = "LC";
+  TaxIdType3[TaxIdType3["FOREIGN_ID"] = 91] = "FOREIGN_ID";
+  TaxIdType3[TaxIdType3["PASSPORT"] = 94] = "PASSPORT";
+  TaxIdType3[TaxIdType3["BUENOS_AIRES_ID"] = 95] = "BUENOS_AIRES_ID";
+  TaxIdType3[TaxIdType3["NATIONAL_POLICE_ID"] = 96] = "NATIONAL_POLICE_ID";
+  TaxIdType3[TaxIdType3["DNI"] = 96] = "DNI";
+  TaxIdType3[TaxIdType3["FINAL_CONSUMER"] = 99] = "FINAL_CONSUMER";
+  return TaxIdType3;
 })(TaxIdType || {});
 var VatCondition = /* @__PURE__ */ ((VatCondition2) => {
   VatCondition2[VatCondition2["IVA_RESPONSABLE_INSCRIPTO"] = 1] = "IVA_RESPONSABLE_INSCRIPTO";
@@ -1067,7 +1083,6 @@ var WsfeService = class _WsfeService {
    * Método genérico interno para emitir cualquier tipo de comprobante.
    */
   async issueDocument(request) {
-    const invoiceNumber = await this.getNextInvoiceNumber(request.type);
     let total = request.total || 0;
     let net = total;
     let vat = 0;
@@ -1080,6 +1095,8 @@ var WsfeService = class _WsfeService {
     if (total <= 0) {
       throw new ArcaValidationError("El monto total debe ser mayor a 0");
     }
+    this.validateBuyer(request.buyer, total);
+    const invoiceNumber = await this.getNextInvoiceNumber(request.type);
     const soapRequest = this.buildCAERequest({
       type: request.type,
       pointOfSale: this.config.pointOfSale,
@@ -1173,6 +1190,23 @@ var WsfeService = class _WsfeService {
       );
     }
   }
+  /**
+   * Valida obligatoriamente al comprador cuando el monto es mayor o igual a $10.000.000 para consumidor final
+   */
+  validateBuyer(buyer, total) {
+    const isFinalConsumer = !buyer || buyer.docType === 99 /* FINAL_CONSUMER */ || buyer.docNumber === "0" || buyer.docNumber === "";
+    if (total >= 1e7 && isFinalConsumer) {
+      const errorMessage = "Para importes mayores o iguales a $10.000.000 es obligatorio identificar al comprador (RG 5824/2026).";
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`[arca-sdk WARNING] ${errorMessage}`);
+      }
+      throw new ArcaValidationError(errorMessage, {
+        total,
+        buyer,
+        hint: "Actualiz\xE1 el objeto buyer con un tipo de documento v\xE1lido (DNI, CUIT, CUIL) y su n\xFAmero correspondiente."
+      });
+    }
+  }
   /**
    * Calcula el IVA agrupado por alícuota (requerido por ARCA para Factura A/B)
    */
@@ -1376,7 +1410,7 @@ var WsfeService = class _WsfeService {
 };
 
 // src/services/padron.ts
-var import_fast_xml_parser2 = require("fast-xml-parser");
+var import_fast_xml_parser3 = require("fast-xml-parser");
 var PadronService = class {
   wsaa;
   config;
@@ -1435,7 +1469,7 @@ var PadronService = class {
    * Parsea la respuesta XML de getPersona
    */
   parseResponse(xml) {
-    const parser = new import_fast_xml_parser2.XMLParser({
+    const parser = new import_fast_xml_parser3.XMLParser({
       ignoreAttributes: false,
       removeNSPrefix: true
     });
@@ -1472,8 +1506,10 @@ var PadronService = class {
       mainActivity: p.descripcionActividadPrincipal,
       isVATRegistered: this.hasTaxId(p, 30),
       // 30 = IVA
-      isMonotax: this.hasTaxId(p, 20),
-      // 20 = Monotributo
+      isMonotax: this.hasTaxId(p, 20) || this.hasTaxId(p, 24) || this.hasTaxId(p, 21),
+      // General o Social/Autónomo
+      isSocialMonotax: this.hasTaxId(p, 24) || this.hasTaxId(p, 21),
+      // 24 = Obra Social / Promovido, 21 = Autónomo
       isVATExempt: this.hasTaxId(p, 32)
       // 32 = IVA Exento
     };
@@ -1521,6 +1557,469 @@ var PadronService = class {
     return [data];
   }
 };
+
+// src/services/caea.ts
+var CaeaService = 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 WsaaService" }
+      );
+    }
+    if (!config.pointOfSale || config.pointOfSale < 1 || config.pointOfSale > 9999) {
+      throw new ArcaValidationError(
+        "Punto de venta inv\xE1lido: debe ser un n\xFAmero entre 1 y 9999",
+        { pointOfSale: config.pointOfSale }
+      );
+    }
+  }
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Métodos del Ciclo de Vida de CAEA
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /**
+   * Solicita un CAEA (Código de Autorización Electrónico Anticipado) para una quincena específica (FECAEASolicitar).
+   */
+  async solicitCAEA(params) {
+    const soapRequest = `<?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:FECAEASolicitar>
+      <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:Periodo>${params.period}</ar:Periodo>
+      <ar:Orden>${params.order}</ar:Orden>
+    </ar:FECAEASolicitar>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await callArcaApi(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECAEASolicitar"
+      },
+      body: soapRequest,
+      timeout: this.config.timeout
+    });
+    if (!response.ok) {
+      throw new ArcaError(`Error HTTP al solicitar CAEA: ${response.status}`, "HTTP_ERROR");
+    }
+    const responseXml = await response.text();
+    const result = parseXml(responseXml);
+    const data = result?.Envelope?.Body?.FECAEASolicitarResponse?.FECAEASolicitarResult;
+    if (!data) {
+      throw new ArcaError("Respuesta FECAEASolicitar inv\xE1lida", "PARSE_ERROR", { xml: responseXml });
+    }
+    if (data.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      const code = error?.Code || "UNKNOWN";
+      throw new ArcaError(
+        `Error ARCA: ${error?.Msg || "Error desconocido"}`,
+        "ARCA_ERROR",
+        data.Errors,
+        getArcaHint(code)
+      );
+    }
+    const res = data.ResultGet;
+    return {
+      caea: String(res.CAEA),
+      period: Number(res.Periodo),
+      order: Number(res.Orden),
+      expiryDate: String(res.FchVto),
+      actualDate: String(res.FchVigDesde),
+      receptionDate: String(res.FchVigHasta),
+      limitDate: String(res.FchTopeInf)
+    };
+  }
+  /**
+   * Consulta un CAEA ya emitido (FECAEAConsultar).
+   */
+  async getCAEA(caea) {
+    const soapRequest = `<?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:FECAEAConsultar>
+      <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:Caea>${caea}</ar:Caea>
+    </ar:FECAEAConsultar>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await callArcaApi(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECAEAConsultar"
+      },
+      body: soapRequest,
+      timeout: this.config.timeout
+    });
+    if (!response.ok) {
+      throw new ArcaError(`Error HTTP al consultar CAEA: ${response.status}`, "HTTP_ERROR");
+    }
+    const responseXml = await response.text();
+    const result = parseXml(responseXml);
+    const data = result?.Envelope?.Body?.FECAEAConsultarResponse?.FECAEAConsultarResult;
+    if (!data) {
+      throw new ArcaError("Respuesta FECAEAConsultar inv\xE1lida", "PARSE_ERROR", { xml: responseXml });
+    }
+    if (data.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      const code = error?.Code || "UNKNOWN";
+      throw new ArcaError(
+        `Error ARCA: ${error?.Msg || "Error desconocido"}`,
+        "ARCA_ERROR",
+        data.Errors,
+        getArcaHint(code)
+      );
+    }
+    const res = data.ResultGet;
+    return {
+      caea: String(res.CAEA),
+      period: Number(res.Periodo),
+      order: Number(res.Orden),
+      expiryDate: String(res.FchVto),
+      actualDate: String(res.FchVigDesde),
+      receptionDate: String(res.FchVigHasta),
+      limitDate: String(res.FchTopeInf)
+    };
+  }
+  /**
+   * Rinde/registra informativamente los comprobantes emitidos en contingencia local bajo un CAEA específico (FECAEARegInformativo).
+   * Soporta el envío en lotes de comprobantes homogéneos del mismo tipo de factura y punto de venta.
+   */
+  async reportCAEAPeriod(params) {
+    if (!params.invoices || params.invoices.length === 0) {
+      throw new ArcaValidationError("Debe proveer al menos un comprobante para realizar la rendici\xF3n del CAEA.");
+    }
+    const firstInvoice = params.invoices[0];
+    const invoiceType = firstInvoice.invoiceType;
+    const countReg = params.invoices.length;
+    const invalidInvoices = params.invoices.filter((inv) => inv.invoiceType !== invoiceType);
+    if (invalidInvoices.length > 0) {
+      throw new ArcaValidationError("Todos los comprobantes en un mismo lote de rendici\xF3n informativa deben poseer el mismo tipo de factura (invoiceType).");
+    }
+    let detXml = "";
+    params.invoices.forEach((inv) => {
+      const date = inv.date || /* @__PURE__ */ new Date();
+      const dateStr = date.toISOString().split("T")[0].replace(/-/g, "");
+      let total = 0;
+      let net = 0;
+      let vat = 0;
+      let vatXml = "";
+      const includesVAT = inv.includesVAT || false;
+      if (inv.items && inv.items.length > 0) {
+        net = round(calculateSubtotal(inv.items, includesVAT));
+        vat = round(calculateVAT(inv.items, includesVAT));
+        total = round(calculateTotal(inv.items, includesVAT));
+        const byRate = /* @__PURE__ */ new Map();
+        inv.items.forEach((item) => {
+          const rate = item.vatRate || 0;
+          let netPrice = item.unitPrice;
+          if (includesVAT && rate) {
+            netPrice = item.unitPrice / (1 + rate / 100);
+          }
+          const base = item.quantity * netPrice;
+          const amount = base * rate / 100;
+          const current = byRate.get(rate) || { base: 0, amount: 0 };
+          byRate.set(rate, {
+            base: current.base + base,
+            amount: current.amount + amount
+          });
+        });
+        const vatEntries = Array.from(byRate.entries()).map(([rate, values]) => ({
+          rate,
+          taxBase: values.base,
+          amount: values.amount
+        }));
+        if (vatEntries.length > 0) {
+          vatXml = "<ar:Iva>";
+          vatEntries.forEach((entry) => {
+            vatXml += `
+            <ar:AlicIva>
+              <ar:Id>${this.getVATCode(entry.rate)}</ar:Id>
+              <ar:BaseImp>${entry.taxBase.toFixed(2)}</ar:BaseImp>
+              <ar:Importe>${entry.amount.toFixed(2)}</ar:Importe>
+            </ar:AlicIva>`;
+          });
+          vatXml += "\n          </ar:Iva>";
+        }
+      }
+      if (total <= 0) {
+        throw new ArcaValidationError(`El monto total del comprobante n\xFAmero ${inv.invoiceNumber} debe ser mayor a 0.`);
+      }
+      const condicionIVAReceptorXml = inv.buyer?.vatCondition !== void 0 ? `
+            <ar:CondicionIVAReceptorId>${inv.buyer.vatCondition}</ar:CondicionIVAReceptorId>` : "";
+      let fechasServicioXml = "";
+      if (inv.concept === 2 /* SERVICES */ || inv.concept === 3 /* PRODUCTS_AND_SERVICES */) {
+        const defaultDateStr = date.toISOString().split("T")[0].replace(/-/g, "");
+        fechasServicioXml = `
+            <ar:FchServDesde>${defaultDateStr}</ar:FchServDesde>
+            <ar:FchServHasta>${defaultDateStr}</ar:FchServHasta>
+            <ar:FchVtoPago>${defaultDateStr}</ar:FchVtoPago>`;
+      }
+      let asocXml = "";
+      if (inv.associatedInvoices && inv.associatedInvoices.length > 0) {
+        asocXml = "<ar:CbtesAsoc>";
+        inv.associatedInvoices.forEach((asoc) => {
+          asocXml += `
+            <ar:CbteAsoc>
+              <ar:Tipo>${asoc.type}</ar:Tipo>
+              <ar:PtoVta>${asoc.pointOfSale}</ar:PtoVta>
+              <ar:Nro>${asoc.invoiceNumber}</ar:Nro>
+              ${asoc.cuit ? `<ar:Cuit>${asoc.cuit}</ar:Cuit>` : ""}
+              ${asoc.date ? `<ar:CbteFch>${asoc.date.toISOString().split("T")[0].replace(/-/g, "")}</ar:CbteFch>` : ""}
+            </ar:CbteAsoc>`;
+        });
+        asocXml += "\n          </ar:CbtesAsoc>";
+      }
+      let optXml = "";
+      if (inv.optionals && inv.optionals.length > 0) {
+        optXml = "<ar:Opcionales>";
+        inv.optionals.forEach((opt) => {
+          optXml += `
+            <ar:Opcional>
+              <ar:Id>${opt.id}</ar:Id>
+              <ar:Valor>${opt.value}</ar:Valor>
+            </ar:Opcional>`;
+        });
+        optXml += "\n          </ar:Opcionales>";
+      }
+      detXml += `
+        <ar:FECAEADetRequest>
+          <ar:Concepto>${inv.concept}</ar:Concepto>
+          <ar:DocTipo>${inv.buyer?.docType || 99}</ar:DocTipo>
+          <ar:DocNro>${inv.buyer?.docNumber || 0}</ar:DocNro>${condicionIVAReceptorXml}
+          <ar:CbteDesde>${inv.invoiceNumber}</ar:CbteDesde>
+          <ar:CbteHasta>${inv.invoiceNumber}</ar:CbteHasta>
+          <ar:CbteFch>${dateStr}</ar:CbteFch>
+          <ar:ImpTotal>${total.toFixed(2)}</ar:ImpTotal>
+          <ar:ImpTotConc>0.00</ar:ImpTotConc>
+          <ar:ImpNeto>${net.toFixed(2)}</ar:ImpNeto>
+          <ar:ImpOpEx>0.00</ar:ImpOpEx>
+          <ar:ImpIVA>${vat.toFixed(2)}</ar:ImpIVA>
+          <ar:ImpTrib>0.00</ar:ImpTrib>
+          <ar:MonId>PES</ar:MonId>
+          <ar:MonCotiz>1</ar:MonCotiz>
+          <ar:CAEA>${params.caea}</ar:CAEA>${fechasServicioXml}
+          ${asocXml}
+          ${vatXml}
+          ${optXml}
+        </ar:FECAEADetRequest>`;
+    });
+    const soapRequest = `<?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:FECAEARegInformativo>
+      <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:FeCAEARegInfReq>
+        <ar:FeCabReq>
+          <ar:CantReg>${countReg}</ar:CantReg>
+          <ar:PtoVta>${this.config.pointOfSale}</ar:PtoVta>
+          <ar:CbteTipo>${invoiceType}</ar:CbteTipo>
+        </ar:FeCabReq>
+        <ar:FeDetReq>${detXml}
+        </ar:FeDetReq>
+      </ar:FeCAEARegInfReq>
+    </ar:FECAEARegInformativo>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await callArcaApi(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECAEARegInformativo"
+      },
+      body: soapRequest,
+      timeout: this.config.timeout
+    });
+    if (!response.ok) {
+      throw new ArcaError(`Error HTTP al rendir CAEA: ${response.status}`, "HTTP_ERROR");
+    }
+    const responseXml = await response.text();
+    const result = parseXml(responseXml);
+    const data = result?.Envelope?.Body?.FECAEARegInformativoResponse?.FECAEARegInformativoResult;
+    if (!data) {
+      throw new ArcaError("Respuesta FECAEARegInformativo inv\xE1lida", "PARSE_ERROR", { xml: responseXml });
+    }
+    if (data.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      const code = error?.Code || "UNKNOWN";
+      throw new ArcaError(
+        `Error ARCA: ${error?.Msg || "Error desconocido"}`,
+        "ARCA_ERROR",
+        data.Errors,
+        getArcaHint(code)
+      );
+    }
+    const cab = data.FeCabResp;
+    const det = Array.isArray(data.FeDetResp.FECAEDetResponse) ? data.FeDetResp.FECAEDetResponse[0] : data.FeDetResp.FECAEDetResponse;
+    const observations = [];
+    if (det?.Observaciones) {
+      const obsArray = Array.isArray(det.Observaciones.Obs) ? det.Observaciones.Obs : [det.Observaciones.Obs];
+      obsArray.forEach((o) => observations.push(o.Msg));
+    }
+    return {
+      caea: String(det.CAEA || params.caea),
+      result: cab.Resultado,
+      pointOfSale: Number(cab.PtoVta),
+      invoiceType: Number(cab.CbteTipo),
+      observations: observations.length > 0 ? observations : void 0
+    };
+  }
+  /**
+   * Informa que un CAEA no tuvo movimientos en la quincena (FECAEASinMovimientoInformar).
+   */
+  async reportCAEANoMovement(params) {
+    const soapRequest = `<?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:FECAEASinMovimientoInformar>
+      <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.pointOfSale}</ar:PtoVta>
+      <ar:Caea>${params.caea}</ar:Caea>
+    </ar:FECAEASinMovimientoInformar>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await callArcaApi(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECAEASinMovimientoInformar"
+      },
+      body: soapRequest,
+      timeout: this.config.timeout
+    });
+    if (!response.ok) {
+      throw new ArcaError(`Error HTTP al informar CAEA sin movimientos: ${response.status}`, "HTTP_ERROR");
+    }
+    const responseXml = await response.text();
+    const result = parseXml(responseXml);
+    const data = result?.Envelope?.Body?.FECAEASinMovimientoInformarResponse?.FECAEASinMovimientoInformarResult;
+    if (!data) {
+      throw new ArcaError("Respuesta FECAEASinMovimientoInformar inv\xE1lida", "PARSE_ERROR", { xml: responseXml });
+    }
+    if (data.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      const code = error?.Code || "UNKNOWN";
+      throw new ArcaError(
+        `Error ARCA: ${error?.Msg || "Error desconocido"}`,
+        "ARCA_ERROR",
+        data.Errors,
+        getArcaHint(code)
+      );
+    }
+  }
+  /**
+   * Consulta si se informó la falta de movimientos de un CAEA (FECAEASinMovimientoConsultar).
+   */
+  async getCAEANoMovement(caea) {
+    const soapRequest = `<?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:FECAEASinMovimientoConsultar>
+      <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.pointOfSale}</ar:PtoVta>
+      <ar:Caea>${caea}</ar:Caea>
+    </ar:FECAEASinMovimientoConsultar>
+  </soapenv:Body>
+</soapenv:Envelope>`;
+    const endpoint = getWsfeEndpoint(this.config.environment);
+    const response = await callArcaApi(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "text/xml; charset=utf-8",
+        "SOAPAction": "http://ar.gov.afip.dif.FEV1/FECAEASinMovimientoConsultar"
+      },
+      body: soapRequest,
+      timeout: this.config.timeout
+    });
+    if (!response.ok) {
+      throw new ArcaError(`Error HTTP al consultar CAEA sin movimientos: ${response.status}`, "HTTP_ERROR");
+    }
+    const responseXml = await response.text();
+    const result = parseXml(responseXml);
+    const data = result?.Envelope?.Body?.FECAEASinMovimientoConsultarResponse?.FECAEASinMovimientoConsultarResult;
+    if (!data) {
+      throw new ArcaError("Respuesta FECAEASinMovimientoConsultar inv\xE1lida", "PARSE_ERROR", { xml: responseXml });
+    }
+    if (data.Errors) {
+      const error = Array.isArray(data.Errors.Err) ? data.Errors.Err[0] : data.Errors.Err;
+      const code = error?.Code || "UNKNOWN";
+      throw new ArcaError(
+        `Error ARCA: ${error?.Msg || "Error desconocido"}`,
+        "ARCA_ERROR",
+        data.Errors,
+        getArcaHint(code)
+      );
+    }
+    return data.ResultGet?.FECAEASinMov || null;
+  }
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Métodos internos auxiliares
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  /**
+   * Mapea alícuotas numéricas a los códigos internos de ARCA
+   */
+  getVATCode(rate) {
+    switch (rate) {
+      case 0:
+        return 3;
+      // 0% / Exento / No gravado (código 3 en catálogo ARCA)
+      case 10.5:
+        return 4;
+      case 21:
+        return 5;
+      case 27:
+        return 6;
+      case 5:
+        return 8;
+      case 2.5:
+        return 9;
+      default:
+        throw new ArcaValidationError(`Al\xEDcuota IVA no soportada por ARCA: ${rate}%`, {
+          supportedRates: [0, 10.5, 21, 27, 5, 2.5]
+        });
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArcaAuthError,
@@ -1528,6 +2027,7 @@ var PadronService = class {
   ArcaNetworkError,
   ArcaValidationError,
   BillingConcept,
+  CaeaService,
   InvoiceType,
   PadronService,
   TaxIdType,