facturas 0.4.0

package/dist/index.js

@@ -0,0 +1,1757 @@
+// 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 ArcaInputError = class extends ArcaError {
+  name = "ArcaInputError";
+  detail;
+  constructor(message, options) {
+    super(message, "ARCA_INPUT_ERROR", options);
+    this.detail = options?.detail;
+  }
+};
+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"
+};
+var PRIVATE_KEY_PEM_PREFIXES = [
+  "-----BEGIN PRIVATE KEY-----",
+  "-----BEGIN RSA PRIVATE KEY-----",
+  "-----BEGIN ENCRYPTED PRIVATE KEY-----"
+];
+var VALID_ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
+var DEFAULT_ARCA_TIMEOUT_MS = 3e4;
+var DEFAULT_ARCA_RETRIES = 0;
+var DEFAULT_ARCA_RETRY_DELAY_MS = 500;
+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 config = {
+    taxId: readEnv(env, variableNames.taxId) ?? "",
+    certificatePem: readEnv(env, variableNames.certificatePem) ?? "",
+    privateKeyPem: readEnv(env, variableNames.privateKeyPem) ?? "",
+    environment: environmentValue ?? environmentInput ?? options.defaultEnvironment ?? "test"
+  };
+  assertArcaClientConfig(config);
+  return normalizeArcaClientConfig(config);
+}
+function assertArcaClientConfig(config) {
+  const invalidFields = [];
+  const normalized = normalizeArcaClientConfig(config);
+  const timeout = normalized.timeout ?? DEFAULT_ARCA_TIMEOUT_MS;
+  const retries = normalized.retries ?? DEFAULT_ARCA_RETRIES;
+  const retryDelay = normalized.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS;
+  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");
+  }
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    invalidFields.push("timeout");
+  }
+  if (!Number.isInteger(retries) || retries < 0) {
+    invalidFields.push("retries");
+  }
+  if (!Number.isFinite(retryDelay) || retryDelay < 0) {
+    invalidFields.push("retryDelay");
+  }
+  const loggerLevel = normalized.logger?.level;
+  if (loggerLevel !== void 0 && !VALID_ARCA_LOG_LEVELS.includes(loggerLevel)) {
+    invalidFields.push("logger.level");
+  }
+  if (normalized.logger?.log !== void 0 && typeof normalized.logger.log !== "function") {
+    invalidFields.push("logger.log");
+  }
+  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 normalizedLoggerLevel = normalizeLogLevelValue(config.logger?.level);
+  return {
+    taxId: config.taxId.trim(),
+    certificatePem: config.certificatePem.trim(),
+    privateKeyPem: config.privateKeyPem.trim(),
+    environment: normalizedEnvironment,
+    timeout: config.timeout ?? DEFAULT_ARCA_TIMEOUT_MS,
+    retries: config.retries ?? DEFAULT_ARCA_RETRIES,
+    retryDelay: config.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS,
+    ...config.logger === void 0 ? {} : {
+      logger: {
+        ...config.logger,
+        ...normalizedLoggerLevel === void 0 ? {} : { level: normalizedLoggerLevel }
+      }
+    }
+  };
+}
+function normalizeEnvironmentValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (ARCA_ENVIRONMENTS.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function readEnv(env, variableName) {
+  return env[variableName]?.trim() || void 0;
+}
+function normalizeLogLevelValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (VALID_ARCA_LOG_LEVELS.includes(normalized)) {
+    return normalized;
+  }
+  return value;
+}
+
+// src/internal/logger.ts
+var ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
+function createArcaLogger(config) {
+  const disabled = config?.disabled ?? false;
+  const level = resolveArcaLogLevel(config?.level);
+  const sink = config?.log ?? defaultArcaLog;
+  const log = (messageLevel, message, ...args) => {
+    if (disabled || !shouldLog(level, messageLevel)) {
+      return;
+    }
+    sink(messageLevel, message, ...args);
+  };
+  return {
+    disabled,
+    level,
+    log,
+    debug(message, ...args) {
+      log("debug", message, ...args);
+    },
+    info(message, ...args) {
+      log("info", message, ...args);
+    },
+    warn(message, ...args) {
+      log("warn", message, ...args);
+    },
+    error(message, ...args) {
+      log("error", message, ...args);
+    }
+  };
+}
+function resolveArcaLogLevel(level) {
+  if (isArcaLogLevel(level)) {
+    return level;
+  }
+  const envLevel = process.env.ARCA_LOG_LEVEL?.trim().toLowerCase();
+  if (isArcaLogLevel(envLevel)) {
+    return envLevel;
+  }
+  return "warn";
+}
+function shouldLog(threshold, messageLevel) {
+  return ARCA_LOG_LEVELS.indexOf(messageLevel) >= ARCA_LOG_LEVELS.indexOf(threshold);
+}
+function isArcaLogLevel(value) {
+  return ARCA_LOG_LEVELS.includes(value);
+}
+function defaultArcaLog(level, message, ...args) {
+  const method = level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error;
+  method(message, ...args);
+}
+
+// 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 && // Public Padron A5/A13 WSDLs expose only a generic validation fault, so
+    // there is no documented not-found-specific fault code to match here.
+    // Keep the current message fallback, but treat it as fragile.
+    error.message.toLowerCase().includes("no existe")) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/services/wsfe.ts
+function createWsfeService(options) {
+  async function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+    const auth = await options.auth.login("wsfe", {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceAuthRefresh
+    });
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      body: {
+        Auth: createWsfeAuth(
+          input.representedTaxId ?? options.config.taxId,
+          auth.token,
+          auth.sign
+        ),
+        ...body
+      }
+    });
+    return unwrapWsfeOperationResult(operation, response.result);
+  }
+  async function executeWsfeOperation(operation, body = {}) {
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      body
+    });
+    return unwrapWsfeOperationResult(operation, response.result);
+  }
+  async function getNextVoucherNumber({
+    representedTaxId,
+    salesPoint,
+    voucherType,
+    forceAuthRefresh
+  }) {
+    const result = await executeWsfeAuthenticatedOperation(
+      "FECompUltimoAutorizado",
+      {
+        representedTaxId,
+        forceAuthRefresh
+      },
+      {
+        PtoVta: salesPoint,
+        CbteTipo: voucherType
+      }
+    );
+    return Number(result.CbteNro ?? 0) + 1;
+  }
+  async function getWsfeCatalog(operation, resultKey, input) {
+    const result = await executeWsfeAuthenticatedOperation(operation, {
+      representedTaxId: input.representedTaxId,
+      forceAuthRefresh: input.forceAuthRefresh
+    });
+    return getWsfeResultEntries(result, resultKey).map(mapWsfeCatalogEntry);
+  }
+  return {
+    async createNextVoucher({ representedTaxId, data }) {
+      const normalizedInput = normalizeWsfeVoucherInput(data);
+      const voucherNumber = await getNextVoucherNumber({
+        representedTaxId,
+        salesPoint: normalizedInput.salesPoint,
+        voucherType: normalizedInput.voucherType
+      });
+      const requestData = mapWsfeVoucherInput(normalizedInput, 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: normalizedInput.salesPoint,
+              CbteTipo: normalizedInput.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
+      };
+    },
+    getNextVoucherNumber,
+    getLastVoucher(input) {
+      return getNextVoucherNumber(input);
+    },
+    async getSalesPoints({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetPtosVenta",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      const rawPoints = result.ResultGet?.PtoVenta;
+      if (!rawPoints) {
+        return [];
+      }
+      const entries = Array.isArray(rawPoints) ? rawPoints : [rawPoints];
+      return entries.map(mapWsfeSalesPoint);
+    },
+    getVoucherTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposCbte", "CbteTipo", input);
+    },
+    getDocumentTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposDoc", "DocTipo", input);
+    },
+    getConceptTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposConcepto", "ConceptoTipo", input);
+    },
+    async getCurrencyTypes({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetTiposMonedas",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      return getWsfeResultEntries(result, "Moneda").map(mapWsfeCurrencyType);
+    },
+    getVatRates(input) {
+      return getWsfeCatalog("FEParamGetTiposIva", "IvaTipo", input);
+    },
+    getTaxTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposTributos", "TributoTipo", input);
+    },
+    getOptionalTypes(input) {
+      return getWsfeCatalog("FEParamGetTiposOpcional", "OpcionalTipo", input);
+    },
+    async getActivities({ representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetActividades",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        }
+      );
+      return getWsfeResultEntries(result, "ActividadesTipo").map(
+        mapWsfeActivityType
+      );
+    },
+    async getReceiverVatConditions({
+      representedTaxId,
+      voucherClass,
+      forceAuthRefresh
+    }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCondicionIvaReceptor",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        },
+        {
+          ...voucherClass === void 0 ? {} : { ClaseCmp: voucherClass }
+        }
+      );
+      return getWsfeResultEntries(result, "CondicionIvaReceptor").map(
+        mapWsfeReceiverVatCondition
+      );
+    },
+    async getServerStatus() {
+      const result = await executeWsfeOperation("FEDummy");
+      return mapWsfeServerStatus(result);
+    },
+    async getQuotation({ currencyId, representedTaxId, forceAuthRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCotizacion",
+        {
+          representedTaxId,
+          forceAuthRefresh
+        },
+        {
+          MonId: currencyId
+        }
+      );
+      const raw = result.ResultGet ?? {};
+      return mapWsfeQuotation(raw);
+    },
+    async getVoucherInfo({
+      representedTaxId,
+      number,
+      salesPoint,
+      voucherType
+    }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FECompConsultar",
+        {
+          representedTaxId
+        },
+        {
+          FeCompConsReq: {
+            CbteNro: number,
+            PtoVta: salesPoint,
+            CbteTipo: voucherType
+          }
+        }
+      );
+      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.sameCurrencyForeignCancellation !== void 0) {
+    data.CanMisMonExt = input.sameCurrencyForeignCancellation;
+  }
+  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.associatedPeriod) {
+    data.PeriodoAsoc = {
+      FchDesde: input.associatedPeriod.startDate,
+      FchHasta: input.associatedPeriod.endDate
+    };
+  }
+  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
+      }))
+    };
+  }
+  if (input.activities) {
+    data.Actividades = {
+      Actividad: input.activities.map((a) => ({
+        Id: a.id
+      }))
+    };
+  }
+  return data;
+}
+function normalizeWsfeVoucherInput(input) {
+  const {
+    voucherDate,
+    serviceStartDate,
+    serviceEndDate,
+    paymentDueDate,
+    associatedVouchers,
+    associatedPeriod,
+    ...rest
+  } = input;
+  return {
+    ...rest,
+    voucherDate: normalizeWsfeDateInput(voucherDate, "voucherDate"),
+    ...serviceStartDate === void 0 ? {} : {
+      serviceStartDate: normalizeWsfeDateInput(
+        serviceStartDate,
+        "serviceStartDate"
+      )
+    },
+    ...serviceEndDate === void 0 ? {} : {
+      serviceEndDate: normalizeWsfeDateInput(
+        serviceEndDate,
+        "serviceEndDate"
+      )
+    },
+    ...paymentDueDate === void 0 ? {} : {
+      paymentDueDate: normalizeWsfeDateInput(
+        paymentDueDate,
+        "paymentDueDate"
+      )
+    },
+    ...associatedVouchers === void 0 ? {} : {
+      associatedVouchers: associatedVouchers.map((voucher, index) => {
+        const { voucherDate: associatedVoucherDate, ...associatedRest } = voucher;
+        return {
+          ...associatedRest,
+          ...associatedVoucherDate === void 0 ? {} : {
+            voucherDate: normalizeWsfeDateInput(
+              associatedVoucherDate,
+              `associatedVouchers[${index}].voucherDate`
+            )
+          }
+        };
+      })
+    },
+    ...associatedPeriod === void 0 ? {} : {
+      associatedPeriod: {
+        startDate: normalizeWsfeDateInput(
+          associatedPeriod.startDate,
+          "associatedPeriod.startDate"
+        ),
+        endDate: normalizeWsfeDateInput(
+          associatedPeriod.endDate,
+          "associatedPeriod.endDate"
+        )
+      }
+    }
+  };
+}
+function normalizeWsfeDateInput(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+      {
+        detail: { field: fieldName, value }
+      }
+    );
+  }
+  const normalizedValue = value.trim();
+  const afipMatch = normalizedValue.match(/^(\d{4})(\d{2})(\d{2})$/);
+  if (afipMatch) {
+    const [, year, month, day] = afipMatch;
+    assertValidCalendarDate(year, month, day, fieldName, normalizedValue);
+    return normalizedValue;
+  }
+  const isoMatch = normalizedValue.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (isoMatch) {
+    const [, year, month, day] = isoMatch;
+    assertValidCalendarDate(year, month, day, fieldName, normalizedValue);
+    return `${year}${month}${day}`;
+  }
+  throw new ArcaInputError(
+    `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+    {
+      detail: { field: fieldName, value: normalizedValue }
+    }
+  );
+}
+function assertValidCalendarDate(yearInput, monthInput, dayInput, fieldName, value) {
+  const year = Number(yearInput);
+  const month = Number(monthInput);
+  const day = Number(dayInput);
+  const candidate = new Date(Date.UTC(year, month - 1, day));
+  if (candidate.getUTCFullYear() !== year || candidate.getUTCMonth() !== month - 1 || candidate.getUTCDate() !== day) {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: received a non-existent calendar date`,
+      {
+        detail: { field: fieldName, value }
+      }
+    );
+  }
+}
+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 mapWsfeCatalogEntry(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? "")
+  };
+}
+function mapWsfeActivityType(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? ""),
+    order: Number(record.Orden ?? 0)
+  };
+}
+function mapWsfeReceiverVatCondition(raw) {
+  const record = raw;
+  return {
+    id: Number(record.Id ?? 0),
+    description: String(record.Desc ?? ""),
+    voucherClass: String(record.Cmp_Clase ?? "")
+  };
+}
+function mapWsfeCurrencyType(raw) {
+  const record = raw;
+  return {
+    id: String(record.Id ?? ""),
+    description: String(record.Desc ?? ""),
+    validFrom: String(record.FchDesde ?? ""),
+    validTo: String(record.FchHasta ?? "")
+  };
+}
+function mapWsfeServerStatus(raw) {
+  return {
+    appServer: String(raw.AppServer ?? ""),
+    dbServer: String(raw.DbServer ?? ""),
+    authServer: String(raw.AuthServer ?? "")
+  };
+}
+function mapWsfeQuotation(raw) {
+  return {
+    currencyId: String(raw.MonId ?? ""),
+    rate: Number(raw.MonCotiz ?? 0),
+    date: String(raw.FchCotiz ?? "")
+  };
+}
+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)}`
+    };
+  });
+}
+function getWsfeResultEntries(result, key) {
+  const rawEntries = result.ResultGet?.[key];
+  if (!rawEntries) {
+    return [];
+  }
+  return (Array.isArray(rawEntries) ? rawEntries : [rawEntries]).map(
+    (entry) => entry
+  );
+}
+
+// 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"
+});
+async function postXml({
+  url,
+  body,
+  contentType,
+  soapAction,
+  useLegacyTlsSecurityLevel0 = false,
+  timeout = 3e4,
+  retries = 0,
+  retryDelay = 500,
+  logger,
+  service,
+  operation
+}) {
+  const totalAttempts = retries + 1;
+  for (let attempt = 1; attempt <= totalAttempts; attempt += 1) {
+    try {
+      return await postXmlOnce({
+        url,
+        body,
+        contentType,
+        soapAction,
+        useLegacyTlsSecurityLevel0,
+        timeout
+      });
+    } catch (error) {
+      if (!(error instanceof ArcaTransportError)) {
+        throw error;
+      }
+      if (attempt >= totalAttempts) {
+        logger?.error("ARCA transport request failed", {
+          service,
+          operation,
+          url,
+          attempt,
+          attempts: totalAttempts,
+          error
+        });
+        throw error;
+      }
+      const nextAttempt = attempt + 1;
+      logger?.warn(
+        `Retrying ARCA request after transport failure (attempt ${nextAttempt}/${totalAttempts})`,
+        {
+          service,
+          operation,
+          url,
+          attempt: nextAttempt,
+          attempts: totalAttempts,
+          error
+        }
+      );
+      await delay(retryDelay);
+    }
+  }
+  throw new ArcaTransportError("ARCA HTTP request exhausted retries");
+}
+async function postXmlOnce({
+  url,
+  body,
+  contentType,
+  soapAction,
+  useLegacyTlsSecurityLevel0,
+  timeout
+}) {
+  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(timeout, () => {
+      request.destroy(
+        new Error(`ARCA HTTP request timed out after ${timeout}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("<");
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// 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, path) {
+  let current = value;
+  for (const key of path) {
+    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 url = serviceConfig.endpoint[options.config.environment];
+      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 startedAt = Date.now();
+      options.logger?.debug("Sending ARCA SOAP request", {
+        service: request.service,
+        operation: request.operation,
+        url
+      });
+      try {
+        const responseXml = await postXml({
+          url,
+          body: xml,
+          contentType,
+          soapAction: serviceConfig.soapVersion === "1.1" ? soapAction : void 0,
+          useLegacyTlsSecurityLevel0: options.config.environment === "production" && serviceConfig.useLegacyTlsSecurityLevel0 === true,
+          timeout: options.config.timeout,
+          retries: options.config.retries,
+          retryDelay: options.config.retryDelay,
+          logger: options.logger,
+          service: request.service,
+          operation: request.operation
+        });
+        options.logger?.debug("Received ARCA SOAP response", {
+          service: request.service,
+          operation: request.operation,
+          durationMs: Date.now() - startedAt
+        });
+        const soapBody = parseSoapBody(responseXml);
+        const [, result] = getSingleBodyEntry(soapBody);
+        return {
+          service: request.service,
+          operation: request.operation,
+          raw: responseXml,
+          result
+        };
+      } catch (error) {
+        if (error instanceof ArcaSoapFaultError) {
+          options.logger?.error("ARCA SOAP fault response", {
+            service: request.service,
+            operation: request.operation,
+            url,
+            faultCode: error.faultCode,
+            error
+          });
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/wsaa/index.ts
+import { createHash } from "crypto";
+import forge from "node-forge";
+function createWsaaAuthModule(options) {
+  const cache = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  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 = getCachedCredentials(cache, cacheKey);
+          if (cached) {
+            options.logger?.debug("Attempting WSAA login", {
+              service,
+              source: "cached"
+            });
+            return cached;
+          }
+        }
+        options.logger?.debug("Attempting WSAA login", {
+          service,
+          source: "fresh"
+        });
+        const credentials = await requestCredentials(options.config, service, {
+          logger: options.logger
+        });
+        options.logger?.info("WSAA login succeeded", {
+          service,
+          expiresAt: credentials.expiresAt
+        });
+        cache.set(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 = getCachedCredentials(cache, cacheKey);
+          if (cached) {
+            options.logger?.warn(
+              "Recovered WSAA coe.alreadyAuthenticated fault",
+              {
+                service,
+                faultCode: error.faultCode
+              }
+            );
+            return cached;
+          }
+        }
+        if (error instanceof ArcaSoapFaultError) {
+          options.logger?.error("WSAA SOAP fault response", {
+            service,
+            operation: "loginCms",
+            url: ARCA_WSAA_CONFIG.endpoint[options.config.environment],
+            faultCode: error.faultCode,
+            error
+          });
+        }
+        throw error;
+      } finally {
+        inFlight.delete(cacheKey);
+      }
+    }
+  };
+}
+async function requestCredentials(config, service, options) {
+  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,
+    timeout: config.timeout,
+    retries: config.retries,
+    retryDelay: config.retryDelay,
+    logger: options?.logger,
+    service: "wsaa",
+    operation: "loginCms"
+  });
+  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;
+}
+function getCachedCredentials(cache, cacheKey) {
+  const localCached = cache.get(cacheKey);
+  if (localCached && isCredentialValid(localCached)) {
+    return localCached;
+  }
+  return null;
+}
+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 logger = createArcaLogger(normalizedConfig.logger);
+  const auth = createWsaaAuthModule({ config: normalizedConfig, logger });
+  const soap = createSoapTransport({ config: normalizedConfig, logger });
+  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,
+  ArcaInputError,
+  ArcaServiceError,
+  ArcaSoapFaultError,
+  ArcaTransportError,
+  assertArcaClientConfig,
+  createArcaClient,
+  createArcaClientConfigFromEnv,
+  createPadronService,
+  createWsfeService,
+  createWsmtxcaService,
+  resolveArcaEnvironment
+};
+//# sourceMappingURL=index.js.map