@lapyme/arca 0.1.0

package/dist/index.js

@@ -0,0 +1,1387 @@
+// src/errors.ts
+var ArcaError = class extends Error {
+  code;
+  name = "ArcaError";
+  constructor(message, code = "ARCA_ERROR", options) {
+    super(message, options);
+    this.code = code;
+  }
+};
+var ArcaConfigurationError = class extends ArcaError {
+  name = "ArcaConfigurationError";
+  constructor(message, options) {
+    super(message, "ARCA_CONFIGURATION_ERROR", options);
+  }
+};
+var ArcaTransportError = class extends ArcaError {
+  name = "ArcaTransportError";
+  statusCode;
+  responseBody;
+  constructor(message, options) {
+    super(message, "ARCA_TRANSPORT_ERROR", options);
+    this.statusCode = options?.statusCode;
+    this.responseBody = options?.responseBody;
+  }
+};
+var ArcaSoapFaultError = class extends ArcaError {
+  name = "ArcaSoapFaultError";
+  faultCode;
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_SOAP_FAULT", options);
+    this.faultCode = options?.faultCode;
+    this.detail = options?.detail;
+  }
+};
+var ArcaServiceError = class extends ArcaError {
+  name = "ArcaServiceError";
+  serviceCode;
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_SERVICE_ERROR", options);
+    this.serviceCode = options?.serviceCode;
+    this.detail = options?.detail;
+  }
+};
+
+// src/config.ts
+var ARCA_ENVIRONMENTS = ["production", "test"];
+var ARCA_ENV_VARIABLES = {
+  taxId: "ARCA_TAX_ID",
+  certificatePem: "ARCA_CERTIFICATE_PEM",
+  privateKeyPem: "ARCA_PRIVATE_KEY_PEM",
+  environment: "ARCA_ENVIRONMENT",
+  wsaaCacheMode: "ARCA_WSAA_CACHE_MODE",
+  wsaaCacheDirectory: "ARCA_WSAA_CACHE_DIRECTORY"
+};
+var PRIVATE_KEY_PEM_PREFIXES = [
+  "-----BEGIN PRIVATE KEY-----",
+  "-----BEGIN RSA PRIVATE KEY-----",
+  "-----BEGIN ENCRYPTED PRIVATE KEY-----"
+];
+function resolveArcaEnvironment(production) {
+  return production ? "production" : "test";
+}
+function createArcaClientConfigFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const variableNames = {
+    ...ARCA_ENV_VARIABLES,
+    ...options.variableNames
+  };
+  const environmentInput = readEnv(env, variableNames.environment);
+  const environmentValue = normalizeEnvironmentValue(environmentInput);
+  const cacheModeInput = readEnv(env, variableNames.wsaaCacheMode);
+  const cacheModeValue = normalizeCacheMode(cacheModeInput);
+  const config = {
+    taxId: readEnv(env, variableNames.taxId) ?? "",
+    certificatePem: readEnv(env, variableNames.certificatePem) ?? "",
+    privateKeyPem: readEnv(env, variableNames.privateKeyPem) ?? "",
+    environment: environmentValue ?? environmentInput ?? options.defaultEnvironment ?? "test"
+  };
+  if (cacheModeValue === "disk" || cacheModeInput === "disk") {
+    config.wsaa = {
+      cache: {
+        mode: cacheModeValue ?? cacheModeInput,
+        directory: readEnv(env, variableNames.wsaaCacheDirectory) ?? ""
+      }
+    };
+  } else if (cacheModeValue === "memory" || cacheModeInput !== void 0) {
+    config.wsaa = {
+      cache: {
+        mode: cacheModeValue ?? cacheModeInput
+      }
+    };
+  }
+  assertArcaClientConfig(config);
+  return normalizeArcaClientConfig(config);
+}
+function assertArcaClientConfig(config) {
+  const invalidFields = [];
+  const normalized = normalizeArcaClientConfig(config);
+  if (!/^\d{11}$/.test(normalized.taxId)) {
+    invalidFields.push("taxId");
+  }
+  if (!normalized.certificatePem.startsWith("-----BEGIN CERTIFICATE-----")) {
+    invalidFields.push("certificatePem");
+  }
+  if (!PRIVATE_KEY_PEM_PREFIXES.some(
+    (prefix) => normalized.privateKeyPem.startsWith(prefix)
+  )) {
+    invalidFields.push("privateKeyPem");
+  }
+  if (!ARCA_ENVIRONMENTS.includes(normalized.environment)) {
+    invalidFields.push("environment");
+  }
+  const cacheConfig = config.wsaa?.cache;
+  if (cacheConfig) {
+    const cacheMode = cacheConfig.mode?.trim().toLowerCase() ?? "memory";
+    if (cacheMode !== "memory" && cacheMode !== "disk") {
+      invalidFields.push("wsaa.cache.mode");
+    }
+    if (cacheMode === "disk" && (!("directory" in cacheConfig) || cacheConfig.directory.trim().length < 1)) {
+      invalidFields.push("wsaa.cache.directory");
+    }
+  }
+  if (invalidFields.length > 0) {
+    throw new ArcaConfigurationError(
+      `Missing or invalid ARCA client config fields: ${invalidFields.join(", ")}`
+    );
+  }
+}
+var ARCA_WSAA_CONFIG = {
+  namespace: "http://wsaa.view.sua.dvadac.desein.afip.gov",
+  endpoint: {
+    production: "https://wsaa.afip.gov.ar/ws/services/LoginCms",
+    test: "https://wsaahomo.afip.gov.ar/ws/services/LoginCms"
+  },
+  soapVersion: "1.1",
+  soapActionBase: "",
+  usesEmptySoapAction: true
+};
+var ARCA_SERVICE_CONFIG = {
+  wsaa: ARCA_WSAA_CONFIG,
+  wsfe: {
+    namespace: "http://ar.gov.afip.dif.FEV1/",
+    endpoint: {
+      production: "https://servicios1.afip.gov.ar/wsfev1/service.asmx",
+      test: "https://wswhomo.afip.gov.ar/wsfev1/service.asmx"
+    },
+    soapVersion: "1.2",
+    soapActionBase: "http://ar.gov.afip.dif.FEV1/",
+    useLegacyTlsSecurityLevel0: true
+  },
+  wsmtxca: {
+    namespace: "http://impl.service.wsmtxca.afip.gov.ar/service/",
+    endpoint: {
+      production: "https://serviciosjava.afip.gov.ar/wsmtxca/services/MTXCAService",
+      test: "https://fwshomo.afip.gov.ar/wsmtxca/services/MTXCAService"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "http://impl.service.wsmtxca.afip.gov.ar/service/"
+  },
+  "padron-a5": {
+    namespace: "http://a5.soap.ws.server.puc.sr/",
+    endpoint: {
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA5",
+      test: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA5"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "",
+    usesEmptySoapAction: true
+  },
+  "padron-a13": {
+    namespace: "http://a13.soap.ws.server.puc.sr/",
+    endpoint: {
+      production: "https://aws.afip.gov.ar/sr-padron/webservices/personaServiceA13",
+      test: "https://awshomo.afip.gov.ar/sr-padron/webservices/personaServiceA13"
+    },
+    soapVersion: "1.1",
+    soapActionBase: "",
+    usesEmptySoapAction: true
+  }
+};
+function getArcaServiceConfig(service) {
+  const serviceConfig = ARCA_SERVICE_CONFIG[service];
+  if (!serviceConfig) {
+    throw new ArcaConfigurationError(
+      `Unsupported ARCA service configuration: ${service}`
+    );
+  }
+  return serviceConfig;
+}
+function normalizeArcaClientConfig(config) {
+  const normalizedEnvironment = normalizeEnvironmentValue(String(config.environment)) ?? config.environment;
+  const normalizedCache = normalizeWsaaCacheConfig(config.wsaa?.cache);
+  return {
+    taxId: config.taxId.trim(),
+    certificatePem: config.certificatePem.trim(),
+    privateKeyPem: config.privateKeyPem.trim(),
+    environment: normalizedEnvironment,
+    ...normalizedCache ? {
+      wsaa: {
+        cache: normalizedCache
+      }
+    } : {}
+  };
+}
+function normalizeWsaaCacheConfig(cache) {
+  if (!cache) {
+    return void 0;
+  }
+  const mode = normalizeCacheMode(cache.mode) ?? "memory";
+  if (mode !== "disk") {
+    return {
+      mode: "memory"
+    };
+  }
+  return {
+    mode,
+    directory: ("directory" in cache ? cache.directory : "").trim()
+  };
+}
+function normalizeEnvironmentValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (ARCA_ENVIRONMENTS.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeCacheMode(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "memory" || normalized === "disk") {
+    return normalized;
+  }
+  return void 0;
+}
+function readEnv(env, variableName) {
+  return env[variableName]?.trim() || void 0;
+}
+
+// src/services/padron.ts
+function createPadronService(options) {
+  return {
+    async getTaxpayerDetails(taxId) {
+      const raw = await executePadronOperation(
+        options,
+        "padron-a5",
+        "getPersona_v2",
+        {
+          idPersona: Number.parseInt(String(taxId), 10)
+        }
+      );
+      if (!raw) {
+        return null;
+      }
+      const record = raw;
+      const datosGenerales = record.datosGenerales;
+      return {
+        taxId: String(record.idPersona ?? ""),
+        ...record.tipoPersona !== void 0 ? { personType: String(record.tipoPersona) } : {},
+        ...datosGenerales ? { name: extractPadronName(datosGenerales) } : {},
+        raw: record
+      };
+    },
+    async getTaxIdByDocument(documentNumber) {
+      const raw = await executePadronOperation(
+        options,
+        "padron-a13",
+        "getIdPersonaListByDocumento",
+        {
+          documento: String(documentNumber)
+        }
+      );
+      if (!raw) {
+        return null;
+      }
+      const record = raw;
+      const idPersona = record.idPersona;
+      const taxIds = Array.isArray(idPersona) ? idPersona.map(String) : idPersona !== void 0 ? [String(idPersona)] : [];
+      return {
+        taxIds,
+        raw: record
+      };
+    }
+  };
+}
+function extractPadronName(datosGenerales) {
+  if (typeof datosGenerales.razonSocial === "string") {
+    return datosGenerales.razonSocial;
+  }
+  const nombre = datosGenerales.nombre;
+  const apellido = datosGenerales.apellido;
+  if (typeof apellido === "string" && typeof nombre === "string") {
+    return `${apellido} ${nombre}`.trim();
+  }
+  if (typeof apellido === "string") {
+    return apellido;
+  }
+  if (typeof nombre === "string") {
+    return nombre;
+  }
+  return void 0;
+}
+async function executePadronOperation(options, service, operation, body) {
+  const auth = await options.auth.login(
+    service === "padron-a5" ? "ws_sr_constancia_inscripcion" : "ws_sr_padron_a13"
+  );
+  try {
+    const response = await options.soap.execute({
+      service,
+      operation,
+      bodyElementNamespaceMode: "prefix",
+      body: {
+        token: auth.token,
+        sign: auth.sign,
+        cuitRepresentada: Number.parseInt(options.config.taxId, 10),
+        ...body
+      }
+    });
+    const operationResponse = response.result;
+    if (operation === "getPersona_v2") {
+      return operationResponse.personaReturn ?? null;
+    }
+    if (operation === "getIdPersonaListByDocumento") {
+      return operationResponse.idPersonaListReturn ?? null;
+    }
+    return operationResponse.return ?? null;
+  } catch (error) {
+    if (error instanceof ArcaSoapFaultError && error.message.toLowerCase().includes("no existe")) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/services/wsfe.ts
+function createWsfeService(options) {
+  async function getLastVoucher({
+    representedTaxId,
+    salesPoint,
+    voucherType,
+    forceAuthRefresh
+  }) {
+    const auth = await options.auth.login("wsfe", {
+      representedTaxId,
+      forceRefresh: forceAuthRefresh
+    });
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation: "FECompUltimoAutorizado",
+      body: {
+        Auth: createWsfeAuth(
+          representedTaxId ?? options.config.taxId,
+          auth.token,
+          auth.sign
+        ),
+        PtoVta: salesPoint,
+        CbteTipo: voucherType
+      }
+    });
+    const result = unwrapWsfeOperationResult(
+      "FECompUltimoAutorizado",
+      response.result
+    );
+    return Number(result.CbteNro ?? 0) + 1;
+  }
+  return {
+    async createNextVoucher({ representedTaxId, data }) {
+      const voucherNumber = await getLastVoucher({
+        representedTaxId,
+        salesPoint: data.salesPoint,
+        voucherType: data.voucherType
+      });
+      const requestData = mapWsfeVoucherInput(data, voucherNumber);
+      const auth = await options.auth.login("wsfe", { representedTaxId });
+      const response = await options.soap.execute({
+        service: "wsfe",
+        operation: "FECAESolicitar",
+        body: {
+          Auth: createWsfeAuth(
+            representedTaxId ?? options.config.taxId,
+            auth.token,
+            auth.sign
+          ),
+          FeCAEReq: {
+            FeCabReq: {
+              CantReg: 1,
+              PtoVta: data.salesPoint,
+              CbteTipo: data.voucherType
+            },
+            FeDetReq: {
+              FECAEDetRequest: requestData
+            }
+          }
+        }
+      });
+      const result = unwrapWsfeOperationResult(
+        "FECAESolicitar",
+        response.result
+      );
+      const detailResponse = normalizeWsfeDetailResponse(result);
+      const cae = detailResponse.CAE;
+      const caeExpiry = detailResponse.CAEFchVto;
+      if (typeof cae !== "string" || typeof caeExpiry !== "string") {
+        throw new ArcaServiceError(
+          "WSFE did not return CAE authorization data",
+          { detail: result }
+        );
+      }
+      return {
+        cae,
+        caeExpiry: String(caeExpiry),
+        voucherNumber,
+        raw: result
+      };
+    },
+    getLastVoucher,
+    async getSalesPoints({ representedTaxId, forceAuthRefresh }) {
+      const auth = await options.auth.login("wsfe", {
+        representedTaxId,
+        forceRefresh: forceAuthRefresh
+      });
+      const response = await options.soap.execute({
+        service: "wsfe",
+        operation: "FEParamGetPtosVenta",
+        body: {
+          Auth: createWsfeAuth(
+            representedTaxId ?? options.config.taxId,
+            auth.token,
+            auth.sign
+          )
+        }
+      });
+      const result = unwrapWsfeOperationResult(
+        "FEParamGetPtosVenta",
+        response.result
+      );
+      const resultGet = result.ResultGet;
+      const rawPoints = resultGet?.PtoVenta;
+      if (!rawPoints) {
+        return [];
+      }
+      const entries = Array.isArray(rawPoints) ? rawPoints : [rawPoints];
+      return entries.map(mapWsfeSalesPoint);
+    },
+    async getVoucherInfo({
+      representedTaxId,
+      number,
+      salesPoint,
+      voucherType
+    }) {
+      const auth = await options.auth.login("wsfe", { representedTaxId });
+      const response = await options.soap.execute({
+        service: "wsfe",
+        operation: "FECompConsultar",
+        body: {
+          Auth: createWsfeAuth(
+            representedTaxId ?? options.config.taxId,
+            auth.token,
+            auth.sign
+          ),
+          FeCompConsReq: {
+            CbteNro: number,
+            PtoVta: salesPoint,
+            CbteTipo: voucherType
+          }
+        }
+      });
+      const result = unwrapWsfeOperationResult(
+        "FECompConsultar",
+        response.result
+      );
+      const raw = result.ResultGet ?? null;
+      if (!raw) {
+        return null;
+      }
+      return mapWsfeVoucherInfo(raw);
+    }
+  };
+}
+function mapWsfeVoucherInput(input, voucherNumber) {
+  const data = {
+    Concepto: input.concept,
+    DocTipo: input.documentType,
+    DocNro: input.documentNumber,
+    CbteDesde: voucherNumber,
+    CbteHasta: voucherNumber,
+    CbteFch: input.voucherDate,
+    ImpTotal: input.totalAmount,
+    ImpTotConc: input.nonTaxableAmount,
+    ImpNeto: input.netAmount,
+    ImpOpEx: input.exemptAmount,
+    ImpTrib: input.taxAmount,
+    ImpIVA: input.vatAmount,
+    MonId: input.currencyId,
+    MonCotiz: input.exchangeRate,
+    PtoVta: input.salesPoint,
+    CbteTipo: input.voucherType
+  };
+  if (input.receiverVatConditionId !== void 0) {
+    data.CondicionIVAReceptorId = input.receiverVatConditionId;
+  }
+  if (input.serviceStartDate !== void 0) {
+    data.FchServDesde = input.serviceStartDate;
+  }
+  if (input.serviceEndDate !== void 0) {
+    data.FchServHasta = input.serviceEndDate;
+  }
+  if (input.paymentDueDate !== void 0) {
+    data.FchVtoPago = input.paymentDueDate;
+  }
+  if (input.associatedVouchers) {
+    data.CbtesAsoc = {
+      CbteAsoc: input.associatedVouchers.map((v) => ({
+        Tipo: v.type,
+        PtoVta: v.salesPoint,
+        Nro: v.number,
+        ...v.taxId !== void 0 ? { Cuit: v.taxId } : {},
+        ...v.voucherDate !== void 0 ? { CbteFch: v.voucherDate } : {}
+      }))
+    };
+  }
+  if (input.taxes) {
+    data.Tributos = {
+      Tributo: input.taxes.map((t) => ({
+        Id: t.id,
+        ...t.description !== void 0 ? { Desc: t.description } : {},
+        BaseImp: t.baseAmount,
+        Alic: t.rate,
+        Importe: t.amount
+      }))
+    };
+  }
+  if (input.vatRates) {
+    data.Iva = {
+      AlicIva: input.vatRates.map((v) => ({
+        Id: v.id,
+        BaseImp: v.baseAmount,
+        Importe: v.amount
+      }))
+    };
+  }
+  if (input.optionalFields) {
+    data.Opcionales = {
+      Opcional: input.optionalFields.map((o) => ({
+        Id: o.id,
+        Valor: o.value
+      }))
+    };
+  }
+  if (input.buyers) {
+    data.Compradores = {
+      Comprador: input.buyers.map((b) => ({
+        DocTipo: b.documentType,
+        DocNro: b.documentNumber,
+        Porcentaje: b.percentage
+      }))
+    };
+  }
+  return data;
+}
+function mapWsfeSalesPoint(raw) {
+  const record = raw;
+  return {
+    number: Number(record.Nro ?? 0),
+    ...record.EmisionTipo !== void 0 ? { emissionType: String(record.EmisionTipo) } : {},
+    ...record.Bloqueado !== void 0 ? { blocked: String(record.Bloqueado) } : {},
+    ...record.FchBaja !== void 0 ? { deletedSince: String(record.FchBaja) } : {}
+  };
+}
+function mapWsfeVoucherInfo(raw) {
+  return {
+    voucherNumber: Number(raw.CbteDesde ?? raw.CbteHasta ?? 0),
+    ...raw.CbteFch !== void 0 ? { voucherDate: String(raw.CbteFch) } : {},
+    ...raw.PtoVta !== void 0 ? { salesPoint: Number(raw.PtoVta) } : {},
+    ...raw.CbteTipo !== void 0 ? { voucherType: Number(raw.CbteTipo) } : {},
+    ...raw.ImpTotal !== void 0 ? { totalAmount: Number(raw.ImpTotal) } : {},
+    ...raw.Resultado !== void 0 ? { result: String(raw.Resultado) } : {},
+    ...raw.CAE !== void 0 ? { cae: String(raw.CAE) } : {},
+    ...raw.CAEFchVto !== void 0 ? { caeExpiry: String(raw.CAEFchVto) } : {},
+    raw
+  };
+}
+function createWsfeAuth(representedTaxId, token, sign) {
+  return {
+    Token: token,
+    Sign: sign,
+    Cuit: Number.parseInt(String(representedTaxId), 10)
+  };
+}
+function unwrapWsfeOperationResult(operation, response) {
+  const operationResponse = response[`${operation}Response`];
+  const result = operationResponse?.[`${operation}Result`] ?? response[`${operation}Result`] ?? response;
+  if (operation === "FECAESolicitar") {
+    const detailResponse = normalizeWsfeDetailResponse(result);
+    const resultCode = detailResponse.Resultado;
+    if (resultCode && resultCode !== "A") {
+      const observationsContainer = detailResponse.Observaciones;
+      const observations = normalizeWsfeErrors(observationsContainer?.Obs);
+      if (observations.length > 0) {
+        const firstObservation = observations[0];
+        if (!firstObservation) {
+          throw new ArcaServiceError(
+            "WSFE returned an empty observation list",
+            {
+              detail: result
+            }
+          );
+        }
+        throw new ArcaServiceError(firstObservation.message, {
+          serviceCode: firstObservation.code,
+          detail: result
+        });
+      }
+    }
+  }
+  const errorsContainer = result.Errors;
+  const errors = normalizeWsfeErrors(errorsContainer?.Err);
+  if (errors.length > 0) {
+    const firstError = errors[0];
+    if (!firstError) {
+      throw new ArcaServiceError("WSFE returned an empty error list", {
+        detail: result
+      });
+    }
+    throw new ArcaServiceError(firstError.message, {
+      serviceCode: firstError.code,
+      detail: result
+    });
+  }
+  return result;
+}
+function normalizeWsfeDetailResponse(result) {
+  const detailResponse = result.FeDetResp;
+  const rawDetail = detailResponse?.FECAEDetResponse;
+  if (Array.isArray(rawDetail)) {
+    return rawDetail[0] ?? {};
+  }
+  return rawDetail ?? {};
+}
+function normalizeWsfeErrors(rawErrors) {
+  const entries = Array.isArray(rawErrors) ? rawErrors : rawErrors ? [rawErrors] : [];
+  return entries.map((entry) => entry).map((entry) => {
+    const code = entry.Code ?? entry.code ?? "N/A";
+    const message = entry.Msg ?? entry.msg ?? "Unknown WSFE error";
+    return {
+      code: String(code),
+      message: `(${String(code)}) ${String(message)}`
+    };
+  });
+}
+
+// src/services/wsmtxca.ts
+function createWsmtxcaService(options) {
+  return {
+    async authorizeVoucher({ representedTaxId, data }) {
+      const auth = await options.auth.login("wsmtxca", { representedTaxId });
+      const response = await options.soap.execute({
+        service: "wsmtxca",
+        operation: "autorizarComprobante",
+        bodyElementName: "autorizarComprobanteRequest",
+        bodyElementNamespaceMode: "prefix",
+        body: {
+          authRequest: createWsmtxcaAuth(
+            representedTaxId ?? options.config.taxId,
+            auth.token,
+            auth.sign
+          ),
+          ...data
+        }
+      });
+      const raw = unwrapWsmtxcaOperationResponse(
+        response.result,
+        "autorizarComprobante"
+      );
+      const authorizationPayload = extractWsmtxcaAuthorizationPayload(raw);
+      const messages = extractWsmtxcaMessages(raw);
+      const resultado = raw.resultado ?? authorizationPayload.resultado;
+      const caeValue = authorizationPayload.CAE ?? authorizationPayload.codigoAutorizacion ?? raw.codigoAutorizacion;
+      if (resultado === "R" || caeValue == null) {
+        throw new ArcaServiceError(
+          messages.join(" | ") || "WSMTXCA rejected the voucher authorization",
+          { detail: raw }
+        );
+      }
+      return {
+        cae: String(caeValue),
+        caeExpiry: normalizeWsmtxcaResponseDate(
+          authorizationPayload.fechaVencimientoCAE ?? authorizationPayload.fechaVencimiento ?? raw.fechaVencimiento
+        ),
+        voucherNumber: parseWsmtxcaVoucherNumber(
+          authorizationPayload.numeroComprobante ?? raw.numeroComprobante,
+          "WSMTXCA did not return the authorized voucher number",
+          raw
+        ),
+        messages,
+        raw
+      };
+    },
+    async getLastAuthorizedVoucher({
+      representedTaxId,
+      voucherType,
+      salesPoint
+    }) {
+      const auth = await options.auth.login("wsmtxca", { representedTaxId });
+      const response = await options.soap.execute({
+        service: "wsmtxca",
+        operation: "consultarUltimoComprobanteAutorizado",
+        bodyElementName: "consultarUltimoComprobanteAutorizadoRequest",
+        bodyElementNamespaceMode: "prefix",
+        body: {
+          authRequest: createWsmtxcaAuth(
+            representedTaxId ?? options.config.taxId,
+            auth.token,
+            auth.sign
+          ),
+          consultaUltimoComprobanteAutorizadoRequest: {
+            codigoTipoComprobante: voucherType,
+            numeroPuntoVenta: salesPoint
+          }
+        }
+      });
+      const raw = unwrapWsmtxcaOperationResponse(
+        response.result,
+        "consultarUltimoComprobanteAutorizado"
+      );
+      return {
+        voucherNumber: parseWsmtxcaVoucherNumber(
+          raw.numeroComprobante ?? raw.cbteNro ?? raw.nroComprobante,
+          extractWsmtxcaMessages(raw).join(" | ") || "WSMTXCA did not return the last authorized voucher number",
+          raw
+        ),
+        raw
+      };
+    },
+    async getVoucher({
+      representedTaxId,
+      voucherType,
+      salesPoint,
+      voucherNumber
+    }) {
+      const auth = await options.auth.login("wsmtxca", { representedTaxId });
+      const response = await options.soap.execute({
+        service: "wsmtxca",
+        operation: "consultarComprobante",
+        bodyElementName: "consultarComprobanteRequest",
+        bodyElementNamespaceMode: "prefix",
+        body: {
+          authRequest: createWsmtxcaAuth(
+            representedTaxId ?? options.config.taxId,
+            auth.token,
+            auth.sign
+          ),
+          consultaComprobanteRequest: {
+            codigoTipoComprobante: voucherType,
+            numeroPuntoVenta: salesPoint,
+            numeroComprobante: voucherNumber
+          }
+        }
+      });
+      const raw = unwrapWsmtxcaOperationResponse(
+        response.result,
+        "consultarComprobante"
+      );
+      const voucher = extractWsmtxcaVoucherPayload(raw);
+      const messages = extractWsmtxcaMessages(raw);
+      const invoiceDate = normalizeWsmtxcaResponseDate(
+        voucher.fechaEmision ?? voucher.fecha ?? voucher.CbteFch
+      );
+      if (!invoiceDate) {
+        throw new ArcaServiceError(
+          messages[0] ?? "WSMTXCA did not return the voucher issue date",
+          { detail: raw }
+        );
+      }
+      return {
+        invoiceDate,
+        voucher,
+        messages,
+        raw
+      };
+    }
+  };
+}
+function createWsmtxcaAuth(representedTaxId, token, sign) {
+  return {
+    token,
+    sign,
+    cuitRepresentada: Number.parseInt(String(representedTaxId), 10)
+  };
+}
+function toRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function unwrapWsmtxcaOperationResponse(response, operation) {
+  const responseRecord = toRecord(response) ?? {};
+  if (operation === "autorizarComprobante") {
+    return toRecord(responseRecord.autorizarComprobanteResponse) ?? toRecord(responseRecord.autorizarComprobanteResult) ?? toRecord(responseRecord.comprobanteCAEResponse) ?? toRecord(responseRecord.comprobanteCAEReponse) ?? responseRecord;
+  }
+  if (operation === "consultarComprobante") {
+    return toRecord(responseRecord.consultarComprobanteResponse) ?? toRecord(responseRecord.consultaComprobanteResponse) ?? toRecord(responseRecord.consultarComprobanteResult) ?? responseRecord;
+  }
+  return toRecord(responseRecord.consultarUltimoComprobanteAutorizadoResponse) ?? toRecord(responseRecord.consultaUltimoComprobanteAutorizadoResponse) ?? toRecord(responseRecord.consultarUltimoComprobanteAutorizadoResult) ?? responseRecord;
+}
+function extractWsmtxcaAuthorizationPayload(raw) {
+  return toRecord(raw.comprobanteResponse) ?? toRecord(raw.comprobanteCAEResponse) ?? toRecord(raw.comprobanteCAEReponse) ?? raw;
+}
+function extractWsmtxcaVoucherPayload(raw) {
+  return toRecord(raw.comprobanteResponse) ?? toRecord(raw.comprobante) ?? toRecord(raw.cmp) ?? raw;
+}
+function extractWsmtxcaMessages(raw) {
+  const rawErrors = raw.arrayErrores;
+  const rawObservations = raw.arrayObservaciones;
+  const toEntries = (value) => {
+    if (!value) {
+      return [];
+    }
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "object") {
+      return [value];
+    }
+    return [];
+  };
+  const errors = toEntries(rawErrors?.codigoDescripcion).map((entry) => {
+    const code = entry.codigo == null ? "N/A" : String(entry.codigo);
+    const description = entry.descripcion == null ? "Unknown WSMTXCA error" : String(entry.descripcion);
+    return `Error ${code}: ${description}`;
+  });
+  const observations = toEntries(rawObservations?.codigoDescripcion).map(
+    (entry) => {
+      const code = entry.codigo == null ? "N/A" : String(entry.codigo);
+      const description = entry.descripcion == null ? "" : String(entry.descripcion);
+      return `Obs ${code}: ${description}`.trim();
+    }
+  );
+  return [...errors, ...observations];
+}
+function parseWsmtxcaVoucherNumber(value, message, detail) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new ArcaServiceError(message, { detail });
+  }
+  return parsed;
+}
+function normalizeWsmtxcaResponseDate(value) {
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return formatCompactDateToIso(value);
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (/^\d{8}$/.test(trimmed)) {
+    return formatCompactDateToIso(Number.parseInt(trimmed, 10));
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) {
+    return trimmed.slice(0, 10);
+  }
+  return void 0;
+}
+function formatCompactDateToIso(dateValue) {
+  if (!dateValue) {
+    return void 0;
+  }
+  const raw = String(dateValue);
+  if (raw.length !== 8) {
+    return void 0;
+  }
+  return `${raw.slice(0, 4)}-${raw.slice(4, 6)}-${raw.slice(6, 8)}`;
+}
+
+// src/internal/http.ts
+import https from "https";
+var defaultAgent = new https.Agent({
+  keepAlive: true
+});
+var legacyTlsAgent = new https.Agent({
+  keepAlive: true,
+  ciphers: "DEFAULT@SECLEVEL=0"
+});
+var REQUEST_TIMEOUT_MS = 3e4;
+async function postXml({
+  url,
+  body,
+  contentType,
+  soapAction,
+  useLegacyTlsSecurityLevel0 = false
+}) {
+  const endpoint = new URL(url);
+  const requestBody = Buffer.from(body, "utf8");
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const settleResolve = (responseBody) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(responseBody);
+    };
+    const settleReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      reject(error);
+    };
+    const request = https.request(
+      {
+        protocol: endpoint.protocol,
+        hostname: endpoint.hostname,
+        port: endpoint.port || void 0,
+        path: `${endpoint.pathname}${endpoint.search}`,
+        method: "POST",
+        agent: useLegacyTlsSecurityLevel0 ? legacyTlsAgent : defaultAgent,
+        headers: {
+          Accept: "text/xml, application/soap+xml",
+          "Content-Length": requestBody.byteLength,
+          "Content-Type": contentType,
+          ...soapAction === void 0 ? {} : { SOAPAction: `"${soapAction}"` }
+        }
+      },
+      (response) => {
+        const chunks = [];
+        const getResponseBody = () => Buffer.concat(chunks).toString("utf8");
+        response.on("data", (chunk) => {
+          chunks.push(
+            typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk
+          );
+        });
+        response.on("error", (error) => {
+          settleReject(
+            new ArcaTransportError(
+              `ARCA HTTP response stream failed: ${error.message}`,
+              {
+                cause: error,
+                statusCode: response.statusCode,
+                responseBody: getResponseBody()
+              }
+            )
+          );
+        });
+        response.on("aborted", () => {
+          settleReject(
+            new ArcaTransportError("ARCA HTTP response was aborted", {
+              statusCode: response.statusCode,
+              responseBody: getResponseBody()
+            })
+          );
+        });
+        response.on("end", () => {
+          const responseBody = getResponseBody();
+          const statusCode = response.statusCode ?? 500;
+          const responseContentType = Array.isArray(
+            response.headers["content-type"]
+          ) ? response.headers["content-type"].join("; ") : response.headers["content-type"];
+          if (statusCode >= 200 && statusCode < 300) {
+            settleResolve(responseBody);
+            return;
+          }
+          if (isXmlLikeResponse(responseBody, responseContentType)) {
+            settleResolve(responseBody);
+            return;
+          }
+          settleReject(
+            new ArcaTransportError(
+              `ARCA HTTP request failed with status ${statusCode}`,
+              {
+                statusCode,
+                responseBody
+              }
+            )
+          );
+        });
+      }
+    );
+    request.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      request.destroy(
+        new Error(`ARCA HTTP request timed out after ${REQUEST_TIMEOUT_MS}ms`)
+      );
+    });
+    request.on("error", (error) => {
+      settleReject(
+        new ArcaTransportError(`ARCA HTTP request failed: ${error.message}`, {
+          cause: error
+        })
+      );
+    });
+    request.write(requestBody);
+    request.end();
+  });
+}
+function isXmlLikeResponse(body, contentType) {
+  const normalizedContentType = contentType?.toLowerCase() ?? "";
+  if (normalizedContentType.includes("xml") || normalizedContentType.includes("soap")) {
+    return true;
+  }
+  return body.trimStart().startsWith("<");
+}
+
+// src/internal/xml.ts
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+var xmlBuilder = new XMLBuilder({
+  attributeNamePrefix: "@_",
+  format: false,
+  ignoreAttributes: false,
+  suppressBooleanAttributes: false,
+  suppressEmptyNode: true
+});
+var xmlParser = new XMLParser({
+  attributeNamePrefix: "@_",
+  ignoreAttributes: false,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  removeNSPrefix: true,
+  trimValues: true
+});
+function buildSoapEnvelope(soapVersion, operation, namespace, body, options) {
+  const prefix = soapVersion === "1.2" ? "soap12" : "soap";
+  const envelopeNamespace = soapVersion === "1.2" ? "http://www.w3.org/2003/05/soap-envelope" : "http://schemas.xmlsoap.org/soap/envelope/";
+  const namespaceMode = options?.namespaceMode ?? "default";
+  const operationElementName = namespaceMode === "prefix" ? `tns:${operation}` : operation;
+  const operationNamespaceAttributes = namespaceMode === "prefix" ? { "@_xmlns:tns": namespace } : { "@_xmlns": namespace };
+  const payload = {
+    [`${prefix}:Envelope`]: {
+      "@_xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+      "@_xmlns:xsd": "http://www.w3.org/2001/XMLSchema",
+      [`@_xmlns:${prefix}`]: envelopeNamespace,
+      [`${prefix}:Body`]: {
+        [operationElementName]: {
+          ...operationNamespaceAttributes,
+          ...pruneUndefinedDeep(body)
+        }
+      }
+    }
+  };
+  return `<?xml version="1.0" encoding="utf-8"?>${xmlBuilder.build(payload)}`;
+}
+function parseSoapBody(xml) {
+  const parsed = xmlParser.parse(xml);
+  const envelope = parsed.Envelope;
+  const body = envelope?.Body;
+  if (!body) {
+    throw new ArcaSoapFaultError("Invalid SOAP response: missing body", {
+      detail: parsed
+    });
+  }
+  const fault = body.Fault;
+  if (fault) {
+    throw createSoapFaultError(fault);
+  }
+  return body;
+}
+function getSingleBodyEntry(body) {
+  const entries = Object.entries(body).filter(([key]) => key !== "@_xmlns");
+  if (entries.length !== 1) {
+    throw new ArcaSoapFaultError(
+      `Invalid SOAP response: expected a single body entry, got ${entries.length}`,
+      {
+        detail: body
+      }
+    );
+  }
+  return entries[0];
+}
+function parseXmlDocument(xml) {
+  return xmlParser.parse(xml);
+}
+function pruneUndefinedDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => pruneUndefinedDeep(item)).filter((item) => item !== void 0);
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, nestedValue]) => nestedValue !== void 0).map(([key, nestedValue]) => [key, pruneUndefinedDeep(nestedValue)]);
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function createSoapFaultError(fault) {
+  const faultCode = typeof fault.faultcode === "string" ? fault.faultcode : getNestedString(fault, ["Code", "Value"]);
+  const message = typeof fault.faultstring === "string" ? fault.faultstring : getNestedString(fault, ["Reason", "Text"]) ?? "ARCA SOAP fault response";
+  return new ArcaSoapFaultError(message, {
+    faultCode: faultCode ?? void 0,
+    detail: fault
+  });
+}
+function getNestedString(value, path2) {
+  let current = value;
+  for (const key of path2) {
+    if (!current || typeof current !== "object") {
+      return null;
+    }
+    current = current[key];
+  }
+  return typeof current === "string" ? current : null;
+}
+
+// src/soap/index.ts
+function createSoapTransport(options) {
+  return {
+    async execute(request) {
+      const serviceConfig = getArcaServiceConfig(request.service);
+      const soapActionOperation = request.operation;
+      const bodyElementName = request.bodyElementName ?? request.operation;
+      const soapAction = serviceConfig.usesEmptySoapAction ? "" : `${serviceConfig.soapActionBase}${soapActionOperation}`;
+      const contentType = serviceConfig.soapVersion === "1.2" ? `application/soap+xml; charset=utf-8; action="${soapAction}"` : 'text/xml; charset="utf-8"';
+      const xml = buildSoapEnvelope(
+        serviceConfig.soapVersion,
+        bodyElementName,
+        serviceConfig.namespace,
+        request.body,
+        {
+          namespaceMode: request.bodyElementNamespaceMode
+        }
+      );
+      const responseXml = await postXml({
+        url: serviceConfig.endpoint[options.config.environment],
+        body: xml,
+        contentType,
+        soapAction: serviceConfig.soapVersion === "1.1" ? soapAction : void 0,
+        useLegacyTlsSecurityLevel0: options.config.environment === "production" && serviceConfig.useLegacyTlsSecurityLevel0 === true
+      });
+      const soapBody = parseSoapBody(responseXml);
+      const [, result] = getSingleBodyEntry(soapBody);
+      return {
+        service: request.service,
+        operation: request.operation,
+        raw: responseXml,
+        result
+      };
+    }
+  };
+}
+
+// src/wsaa/index.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import forge from "node-forge";
+function createWsaaAuthModule(options) {
+  const cache = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const persistedCache = createPersistedCredentialStore(options.config.wsaa?.cache);
+  return {
+    async login(service, authOptions = {}) {
+      const cacheKey = buildWsaaCacheKey(options.config, service);
+      const running = inFlight.get(cacheKey);
+      if (running) {
+        return running;
+      }
+      const loginPromise = (async () => {
+        if (!authOptions.forceRefresh) {
+          const cached = await getCachedCredentials(
+            cache,
+            cacheKey,
+            persistedCache
+          );
+          if (cached) {
+            return cached;
+          }
+        }
+        const credentials = await requestCredentials(options.config, service);
+        cache.set(cacheKey, credentials);
+        await persistedCache.write(cacheKey, credentials);
+        return credentials;
+      })();
+      inFlight.set(cacheKey, loginPromise);
+      try {
+        return await loginPromise;
+      } catch (error) {
+        if (!authOptions.forceRefresh && error instanceof ArcaSoapFaultError && error.faultCode === "ns1:coe.alreadyAuthenticated") {
+          const cached = await getCachedCredentials(
+            cache,
+            cacheKey,
+            persistedCache
+          );
+          if (cached) {
+            return cached;
+          }
+        }
+        throw error;
+      } finally {
+        inFlight.delete(cacheKey);
+      }
+    }
+  };
+}
+async function requestCredentials(config, service) {
+  const loginTicketRequestXml = buildLoginTicketRequest(service);
+  const signedCms = signLoginTicketRequest(loginTicketRequestXml, {
+    certificatePem: config.certificatePem,
+    privateKeyPem: config.privateKeyPem
+  });
+  const requestXml = buildSoapEnvelope(
+    ARCA_WSAA_CONFIG.soapVersion,
+    "loginCms",
+    ARCA_WSAA_CONFIG.namespace,
+    { in0: signedCms }
+  );
+  const responseXml = await postXml({
+    url: ARCA_WSAA_CONFIG.endpoint[config.environment],
+    body: requestXml,
+    contentType: 'text/xml; charset="utf-8"',
+    soapAction: ARCA_WSAA_CONFIG.soapActionBase
+  });
+  const soapBody = parseSoapBody(responseXml);
+  const [, response] = getSingleBodyEntry(soapBody);
+  const loginCmsReturn = response.loginCmsReturn;
+  if (typeof loginCmsReturn !== "string" || loginCmsReturn.trim().length < 1) {
+    throw new ArcaTransportError(
+      "WSAA response did not include loginCmsReturn XML"
+    );
+  }
+  return parseLoginTicketResponse(loginCmsReturn);
+}
+function buildWsaaCacheKey(config, service) {
+  return [config.environment, service, getCertificateFingerprint(config)].join(
+    ":"
+  );
+}
+function getCertificateFingerprint(config) {
+  return createHash("sha256").update(config.certificatePem).digest("hex");
+}
+function isCredentialValid(credentials) {
+  return new Date(credentials.expiresAt).getTime() - Date.now() > 6e4;
+}
+async function getCachedCredentials(cache, cacheKey, persistedCache) {
+  const localCached = cache.get(cacheKey);
+  if (localCached && isCredentialValid(localCached)) {
+    return localCached;
+  }
+  const persisted = await persistedCache.read(cacheKey);
+  if (persisted) {
+    cache.set(cacheKey, persisted);
+    return persisted;
+  }
+  return null;
+}
+function createPersistedCredentialStore(cacheConfig) {
+  if (!cacheConfig || cacheConfig.mode !== "disk") {
+    return {
+      async read() {
+        return null;
+      },
+      async write() {
+      }
+    };
+  }
+  const cacheDir = path.resolve(cacheConfig.directory);
+  return {
+    async read(cacheKey) {
+      try {
+        const serialized = await readFile(
+          getSharedCacheFilePath(cacheDir, cacheKey),
+          "utf8"
+        );
+        const parsed = JSON.parse(serialized);
+        if (typeof parsed.token !== "string" || typeof parsed.sign !== "string" || typeof parsed.expiresAt !== "string") {
+          return null;
+        }
+        const credentials = {
+          token: parsed.token,
+          sign: parsed.sign,
+          expiresAt: parsed.expiresAt
+        };
+        return isCredentialValid(credentials) ? credentials : null;
+      } catch {
+        return null;
+      }
+    },
+    async write(cacheKey, credentials) {
+      await mkdir(cacheDir, { recursive: true });
+      await writeFile(
+        getSharedCacheFilePath(cacheDir, cacheKey),
+        JSON.stringify(credentials),
+        "utf8"
+      );
+    }
+  };
+}
+function getSharedCacheFilePath(cacheDir, cacheKey) {
+  const fileName = `${createHash("sha256").update(cacheKey).digest("hex")}.json`;
+  return path.join(cacheDir, fileName);
+}
+function buildLoginTicketRequest(service) {
+  const uniqueId = Math.floor(Date.now() / 1e3);
+  const generationTime = new Date(Date.now() - 5 * 6e4).toISOString().replace(".000Z", "Z");
+  const expirationTime = new Date(Date.now() + 5 * 6e4).toISOString().replace(".000Z", "Z");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<loginTicketRequest version="1.0">
+  <header>
+    <uniqueId>${uniqueId}</uniqueId>
+    <generationTime>${generationTime}</generationTime>
+    <expirationTime>${expirationTime}</expirationTime>
+  </header>
+  <service>${service}</service>
+</loginTicketRequest>`;
+}
+function signLoginTicketRequest(loginTicketRequestXml, options) {
+  const certificate = forge.pki.certificateFromPem(options.certificatePem);
+  const privateKey = forge.pki.privateKeyFromPem(options.privateKeyPem);
+  const signedData = forge.pkcs7.createSignedData();
+  signedData.content = forge.util.createBuffer(loginTicketRequestXml, "utf8");
+  signedData.addCertificate(certificate);
+  const authenticatedAttributes = [
+    {
+      type: String(forge.pki.oids.contentType),
+      value: String(forge.pki.oids.data)
+    },
+    {
+      type: String(forge.pki.oids.messageDigest)
+    },
+    {
+      type: String(forge.pki.oids.signingTime),
+      value: /* @__PURE__ */ new Date()
+    }
+  ];
+  const signerOptions = {
+    key: privateKey,
+    certificate,
+    digestAlgorithm: String(forge.pki.oids.sha1),
+    authenticatedAttributes
+  };
+  signedData.addSigner(signerOptions);
+  signedData.sign();
+  const der = forge.asn1.toDer(signedData.toAsn1()).getBytes();
+  return Buffer.from(der, "binary").toString("base64");
+}
+function parseLoginTicketResponse(xml) {
+  const parsed = parseXmlDocument(xml);
+  const response = parsed.loginTicketResponse ?? parsed;
+  const header = response.header;
+  const credentials = response.credentials;
+  const token = credentials?.token;
+  const sign = credentials?.sign;
+  const expiresAt = header?.expirationTime;
+  if (typeof token !== "string" || typeof sign !== "string" || typeof expiresAt !== "string") {
+    throw new ArcaTransportError(
+      "Invalid WSAA login ticket response structure"
+    );
+  }
+  return {
+    token,
+    sign,
+    expiresAt
+  };
+}
+
+// src/client.ts
+function createArcaClient(config) {
+  assertArcaClientConfig(config);
+  const normalizedConfig = normalizeArcaClientConfig(config);
+  const auth = createWsaaAuthModule({ config: normalizedConfig });
+  const soap = createSoapTransport({ config: normalizedConfig });
+  return {
+    config: normalizedConfig,
+    wsfe: createWsfeService({ config: normalizedConfig, auth, soap }),
+    wsmtxca: createWsmtxcaService({ config: normalizedConfig, auth, soap }),
+    padron: createPadronService({ config: normalizedConfig, auth, soap })
+  };
+}
+export {
+  ARCA_ENVIRONMENTS,
+  ARCA_ENV_VARIABLES,
+  ArcaConfigurationError,
+  ArcaError,
+  ArcaServiceError,
+  ArcaSoapFaultError,
+  ArcaTransportError,
+  assertArcaClientConfig,
+  createArcaClient,
+  createArcaClientConfigFromEnv,
+  createPadronService,
+  createWsfeService,
+  createWsmtxcaService,
+  resolveArcaEnvironment
+};
+//# sourceMappingURL=index.js.map