facturas 0.7.1 → 0.9.0

package/dist/index.mjs

@@ -1,16 +1,29 @@
 import {
   createPadronService
-} from "./chunk-EDY3PNKJ.mjs";
+} from "./chunk-7LEKQ4P7.mjs";
 import {
   buildFacturaB,
   buildFacturaC,
-  createWsfeService
-} from "./chunk-OHHXHYLV.mjs";
-import "./chunk-VVY2LZIZ.mjs";
+  calculateWsfeAmounts,
+  createWsfeService,
+  normalizeArcaAmountToMinorUnits,
+  normalizeWsfeDateInput,
+  normalizeWsfeVoucherInput,
+  serializeArcaExchangeRate
+} from "./chunk-RCM4NAAG.mjs";
+import {
+  ARCA_CURRENCY_IDS,
+  ARCA_DOCUMENT_TYPES,
+  ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS,
+  ARCA_INVOICE_CLASS_BY_ISSUER,
+  ARCA_ISSUER_CONDITION_IDS,
+  ARCA_RECEIVER_CONDITION_IDS,
+  ARCA_VOUCHER_TYPES
+} from "./chunk-76WU5BVI.mjs";
 import {
   createWsmtxcaService
-} from "./chunk-A3C3Y5PI.mjs";
-import "./chunk-IOKZX6CA.mjs";
+} from "./chunk-XNBD5NVL.mjs";
+import "./chunk-4QVFXT35.mjs";
 import {
   ArcaAuthenticationError,
   ArcaConfigurationError,
@@ -22,8 +35,9 @@ import {
   ArcaTransportError,
   createResponseBodyDiagnostic,
   createSafeErrorDiagnostic,
-  isArcaAuthenticationError
-} from "./chunk-MBWOFO67.mjs";
+  isArcaAuthenticationError,
+  toArcaSafeErrorMetadata
+} from "./chunk-ZOSNASXB.mjs";
 
 // src/config.ts
 var ARCA_ENVIRONMENTS = ["production", "test"];
@@ -74,17 +88,7 @@ function assertArcaClientConfig(config) {
       "Encrypted private keys are not supported. Provide an unencrypted PKCS#8 or RSA private key PEM."
     );
   }
-  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");
-  }
+  invalidFields.push(...invalidCredentialFields(normalized));
   if (!ARCA_ENVIRONMENTS.includes(normalized.environment)) {
     invalidFields.push("environment");
   }
@@ -196,10 +200,11 @@ 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,
+    taxId: config.taxId?.trim() ?? "",
+    certificatePem: config.certificatePem?.trim() ?? "",
+    privateKeyPem: config.privateKeyPem?.trim() ?? "",
+    environment: normalizedEnvironment ?? "test",
+    ...config.store === void 0 ? {} : { store: config.store },
     timeout: config.timeout ?? DEFAULT_ARCA_TIMEOUT_MS,
     retries: config.retries ?? DEFAULT_ARCA_RETRIES,
     retryDelay: config.retryDelay ?? DEFAULT_ARCA_RETRY_DELAY_MS,
@@ -235,6 +240,40 @@ function normalizeLogLevelValue(value) {
   }
   return value;
 }
+function discoverArcaClientConfig(config) {
+  const environment = config.environment ?? readEnv(process.env, ARCA_ENV_VARIABLES.environment);
+  if (environment === void 0) {
+    throw new ArcaConfigurationError(
+      `environment is required: pass environment or set ${ARCA_ENV_VARIABLES.environment} to "test" or "production".`
+    );
+  }
+  return {
+    ...config,
+    taxId: config.taxId ?? readEnv(process.env, ARCA_ENV_VARIABLES.taxId) ?? "",
+    certificatePem: config.certificatePem ?? readEnv(process.env, ARCA_ENV_VARIABLES.certificatePem) ?? "",
+    privateKeyPem: config.privateKeyPem ?? readEnv(process.env, ARCA_ENV_VARIABLES.privateKeyPem) ?? "",
+    environment
+  };
+}
+function invalidCredentialFields(normalized) {
+  const invalidFields = [];
+  if (!/^\d{11}$/.test(normalized.taxId)) {
+    invalidFields.push(normalized.taxId ? "taxId" : "taxId (ARCA_TAX_ID)");
+  }
+  if (!normalized.certificatePem.startsWith("-----BEGIN CERTIFICATE-----")) {
+    invalidFields.push(
+      normalized.certificatePem ? "certificatePem" : "certificatePem (ARCA_CERTIFICATE_PEM)"
+    );
+  }
+  if (!PRIVATE_KEY_PEM_PREFIXES.some(
+    (prefix) => normalized.privateKeyPem.startsWith(prefix)
+  )) {
+    invalidFields.push(
+      normalized.privateKeyPem ? "privateKeyPem" : "privateKeyPem (ARCA_PRIVATE_KEY_PEM)"
+    );
+  }
+  return invalidFields;
+}
 
 // src/internal/logger.ts
 var ARCA_LOG_LEVELS = ["debug", "info", "warn", "error"];
@@ -287,6 +326,1076 @@ function defaultArcaLog(level, message, ...args) {
   method(message, ...args);
 }
 
+// src/store/types.ts
+import { createHash } from "crypto";
+function attemptKey(environment, taxId, key) {
+  return `arca:v1:attempt:${environment}:${taxId}:${key}`;
+}
+function canonicalHash(input) {
+  return createHash("sha256").update(JSON.stringify(canonical(input))).digest("hex");
+}
+function canonical(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonical);
+  }
+  if (value instanceof Date) {
+    return value.toJSON();
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)])
+    );
+  }
+  return value;
+}
+async function storeCall(fn) {
+  try {
+    return await fn();
+  } catch (cause) {
+    throw new ArcaConfigurationError("ARCA store operation failed.", { cause });
+  }
+}
+
+// src/services/wsfe-derive.ts
+var INVOICE_TYPES = {
+  A: ARCA_VOUCHER_TYPES.FACTURA_A,
+  B: ARCA_VOUCHER_TYPES.FACTURA_B,
+  C: ARCA_VOUCHER_TYPES.FACTURA_C
+};
+function deriveWsfeInvoice(input, now = /* @__PURE__ */ new Date()) {
+  assertIssueObject(input, "input");
+  assertIssueKeys(
+    input,
+    [
+      "issuer",
+      "items",
+      "salesPoint",
+      "to",
+      "total",
+      "date",
+      "currency",
+      "exchangeRate",
+      "service"
+    ],
+    "input"
+  );
+  if (typeof input.issuer !== "string" || !Object.hasOwn(ARCA_ISSUER_CONDITION_IDS, input.issuer)) {
+    invalid(
+      "issuer",
+      "responsable_inscripto, monotributo, exento, or no_alcanzado"
+    );
+  }
+  if (!Number.isSafeInteger(input.salesPoint) || input.salesPoint < 1 || input.salesPoint > 99999) {
+    invalid("salesPoint", "an integer from 1 through 99999");
+  }
+  const receiver = deriveReceiver(input.to);
+  const voucherClass = ARCA_INVOICE_CLASS_BY_ISSUER[input.issuer][input.to.condition];
+  const { data: amountsData, amounts } = calculateWsfeAmounts(input);
+  const currency = deriveCurrency(input);
+  if (input.to.condition === "consumidor_final" && receiver.documentType === ARCA_DOCUMENT_TYPES.CONSUMIDOR_FINAL) {
+    const [whole, fraction = ""] = currency.exchangeRate.split(".");
+    const rate = BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"));
+    if (BigInt(amounts.sentTotal) * rate >= ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS * 1000000n) {
+      throw new ArcaInputError(
+        "The final consumer must be identified for this amount.",
+        {
+          code: "ARCA_INPUT_MISSING_FIELD",
+          field: "to",
+          expected: "cuit or dni for operations at or above ARS 10,000,000 (RG 5866)"
+        }
+      );
+    }
+  }
+  const voucherDate = normalizeWsfeDateInput(
+    input.date === void 0 ? buenosAiresDate(now) : input.date,
+    "date"
+  );
+  const data = {
+    salesPoint: input.salesPoint,
+    voucherType: INVOICE_TYPES[voucherClass],
+    voucherDate,
+    ...receiver,
+    ...currency,
+    ...amountsData,
+    ...deriveService(input.service, voucherDate)
+  };
+  try {
+    normalizeWsfeVoucherInput(data);
+  } catch (cause) {
+    throw new ArcaError(
+      "The derived invoice failed exact WSFE validation. This is an SDK invariant failure.",
+      "ARCA_ISSUE_INVARIANT",
+      { cause }
+    );
+  }
+  return { data, voucherClass, amounts };
+}
+function deriveReceiver(to) {
+  assertIssueObject(to, "to");
+  assertIssueKeys(to, ["condition", "cuit", "dni"], "to");
+  if (typeof to.condition !== "string" || !Object.hasOwn(ARCA_RECEIVER_CONDITION_IDS, to.condition)) {
+    invalid("to.condition", "one of the five supported receiver conditions");
+  }
+  if (to.cuit !== void 0 && to.dni !== void 0) {
+    invalid("to", "either cuit or dni, never both");
+  }
+  if (to.condition !== "consumidor_final" && to.cuit === void 0) {
+    throw new ArcaInputError(
+      "to.cuit is required for this receiver (WSFE 10063 for class A).",
+      {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "to.cuit",
+        expected: "an 11-digit CUIT"
+      }
+    );
+  }
+  const documentType = to.cuit === void 0 ? to.dni === void 0 ? ARCA_DOCUMENT_TYPES.CONSUMIDOR_FINAL : ARCA_DOCUMENT_TYPES.DNI : ARCA_DOCUMENT_TYPES.CUIT;
+  const documentNumber = to.cuit === void 0 ? to.dni === void 0 ? 0 : issueDocumentNumber(to.dni, "to.dni", 1, 11) : issueDocumentNumber(to.cuit, "to.cuit", 11, 11);
+  return {
+    documentType,
+    documentNumber,
+    receiverVatConditionId: ARCA_RECEIVER_CONDITION_IDS[to.condition]
+  };
+}
+function issueDocumentNumber(value, field, min, max) {
+  if (typeof value !== "number" && typeof value !== "string") {
+    invalid(field, `a positive document number with ${min} to ${max} digits`);
+  }
+  const text = String(value);
+  if (!/^\d+$/.test(text) || text.length < min || text.length > max || !Number.isSafeInteger(Number(text)) || Number(text) <= 0) {
+    invalid(field, `a positive document number with ${min} to ${max} digits`);
+  }
+  return Number(text);
+}
+function deriveCurrency(input) {
+  const currency = input.currency === void 0 ? "ARS" : input.currency;
+  if (currency !== "ARS" && currency !== "USD") {
+    invalid("currency", "ARS or USD");
+  }
+  if (input.exchangeRate !== void 0 && typeof input.exchangeRate !== "string") {
+    invalid("exchangeRate", "a decimal string");
+  }
+  if (currency === "USD" && input.exchangeRate === void 0) {
+    throw new ArcaInputError("exchangeRate is required for USD.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "exchangeRate",
+      expected: "a positive decimal string"
+    });
+  }
+  const exchangeRate = serializeArcaExchangeRate(
+    input.exchangeRate ?? "1",
+    "exchangeRate"
+  );
+  if (currency === "ARS" && exchangeRate !== "1") {
+    throw new ArcaInputError("exchangeRate must be 1 for ARS.", {
+      code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
+      field: "exchangeRate",
+      expected: "1 for ARS"
+    });
+  }
+  return { currencyId: ARCA_CURRENCY_IDS[currency], exchangeRate };
+}
+function deriveService(service, date) {
+  if (service === void 0) {
+    return { concept: 1 };
+  }
+  assertIssueObject(service, "service");
+  assertIssueKeys(service, ["from", "to", "dueDate"], "service");
+  for (const field of ["from", "to", "dueDate"]) {
+    if (service[field] === void 0) {
+      throw new ArcaInputError(`service.${field} is required.`, {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: `service.${field}`,
+        expected: "a calendar date"
+      });
+    }
+  }
+  const serviceStartDate = normalizeWsfeDateInput(
+    service.from,
+    "service.from"
+  );
+  const serviceEndDate = normalizeWsfeDateInput(
+    service.to,
+    "service.to"
+  );
+  const paymentDueDate = normalizeWsfeDateInput(
+    service.dueDate,
+    "service.dueDate"
+  );
+  if (serviceEndDate < serviceStartDate) {
+    invalid("service.to", "a date on or after service.from");
+  }
+  if (paymentDueDate < date) {
+    invalid("service.dueDate", "a date on or after date");
+  }
+  return { concept: 2, serviceStartDate, serviceEndDate, paymentDueDate };
+}
+function buenosAiresDate(now) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/Argentina/Buenos_Aires",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(now);
+  return ["year", "month", "day"].map((part) => parts.find((entry) => entry.type === part)?.value).join("");
+}
+function assertIssueObject(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    invalid(field, "an object");
+  }
+}
+function assertIssueKeys(value, keys, prefix) {
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key)) {
+      const field = prefix === "input" ? key : `${prefix}.${key}`;
+      throw new ArcaInputError(`${field} is not supported by issue().`, {
+        code: "ARCA_INPUT_RESERVED_FIELD",
+        field,
+        expected: "a supported facade field; use the exact API for other fiscal fields"
+      });
+    }
+  }
+}
+function invalid(field, expected) {
+  throw new ArcaInputError(`${field} must be ${expected}.`, {
+    code: "ARCA_INPUT_INVALID_VALUE",
+    field,
+    expected
+  });
+}
+
+// src/services/wsfe-cancel.ts
+var NOTES = {
+  1: { voucherType: 3, voucherClass: "A" },
+  6: { voucherType: 8, voucherClass: "B" },
+  11: { voucherType: 13, voucherClass: "C" }
+};
+function invalid2(reason) {
+  throw new ArcaInputError(
+    `Cannot cancel: ${reason}. Use wsfe.issue() for exact control.`,
+    { code: "ARCA_INPUT_INVALID_VALUE" }
+  );
+}
+function required(value, field) {
+  if (value === void 0 || value === null) {
+    invalid2(`original is missing ${field}`);
+  }
+  return value;
+}
+function deriveWsfeCancellation(original, date, now = /* @__PURE__ */ new Date()) {
+  const note = NOTES[original.voucherType ?? 0];
+  if (!note) {
+    invalid2("original must be an invoice of type 1, 6 or 11");
+  }
+  if (!(["A", "O"].includes(original.result ?? "") && original.cae?.trim() && original.caeExpiry?.trim())) {
+    invalid2("original is not authorized");
+  }
+  rejectExtensions(original);
+  if (original.currencyId !== "PES" && original.currencyId !== "DOL") {
+    invalid2("unsupported currency; only ARS and USD are supported");
+  }
+  const voucherDate = normalizeWsfeDateInput(
+    date ?? buenosAiresDate(now),
+    "date"
+  );
+  const originalDate = normalizeWsfeDateInput(
+    required(original.voucherDate, "voucherDate"),
+    "original.voucherDate"
+  );
+  if (originalDate > voucherDate && originalDate.slice(0, 6) !== voucherDate.slice(0, 6)) {
+    invalid2(
+      "original date is later than the note and outside its month (10210)"
+    );
+  }
+  const data = {
+    salesPoint: required(original.salesPoint, "salesPoint"),
+    voucherType: note.voucherType,
+    concept: required(original.concept, "concept"),
+    documentType: required(original.documentType, "documentType"),
+    documentNumber: Number(required(original.documentNumber, "documentNumber")),
+    receiverVatConditionId: required(
+      original.receiverVatConditionId,
+      "receiverVatConditionId"
+    ),
+    currencyId: original.currencyId,
+    exchangeRate: required(original.exchangeRate, "exchangeRate"),
+    voucherDate,
+    totalAmount: required(original.totalAmount, "totalAmount"),
+    netAmount: required(original.netAmount, "netAmount"),
+    vatAmount: required(original.vatAmount, "vatAmount"),
+    exemptAmount: required(original.exemptAmount, "exemptAmount"),
+    nonTaxableAmount: required(original.nonTaxableAmount, "nonTaxableAmount"),
+    taxAmount: required(original.taxAmount, "taxAmount"),
+    ...original.vatRates === void 0 ? {} : { vatRates: original.vatRates.map((rate) => ({ ...rate })) },
+    associatedVouchers: [
+      {
+        type: required(original.voucherType, "voucherType"),
+        salesPoint: required(original.salesPoint, "salesPoint"),
+        number: original.voucherNumber,
+        voucherDate: originalDate
+      }
+    ]
+  };
+  copyServiceDates(original, data);
+  normalizeWsfeVoucherInput(data);
+  const total = Number(
+    normalizeArcaAmountToMinorUnits(data.totalAmount, "totalAmount")
+  );
+  return {
+    data,
+    voucherClass: note.voucherClass,
+    amounts: { computedTotal: total, sentTotal: total, vatAdjustment: 0 }
+  };
+}
+function rejectExtensions(original) {
+  for (const [field, rawField] of [
+    ["taxes", "Tributos"],
+    ["optionalFields", "Opcionales"],
+    ["buyers", "Compradores"],
+    ["activities", "Actividades"],
+    ["associatedPeriod", "PeriodoAsoc"]
+  ]) {
+    const value = original[field];
+    const raw = original.raw[rawField];
+    if (present(value) || present(raw)) {
+      invalid2(`unsupported original ${field}`);
+    }
+  }
+  if ((original.taxAmount ?? 0) !== 0) {
+    invalid2("unsupported original taxes");
+  }
+}
+function present(value) {
+  return value !== void 0 && value !== null && value !== "" && (!Array.isArray(value) || value.length > 0);
+}
+function copyServiceDates(original, data) {
+  if (data.concept !== 2 && data.concept !== 3) {
+    return;
+  }
+  data.serviceStartDate = required(
+    original.serviceStartDate,
+    "serviceStartDate"
+  );
+  data.serviceEndDate = required(
+    original.serviceEndDate,
+    "serviceEndDate"
+  );
+  const due = normalizeWsfeDateInput(
+    required(original.paymentDueDate, "paymentDueDate"),
+    "original.paymentDueDate"
+  );
+  data.paymentDueDate = due < data.voucherDate ? data.voucherDate : due;
+}
+
+// src/services/wsfe-identity.ts
+function matchWsfeVoucherIdentity(sent, number, found) {
+  let missing;
+  const compare = (field, expected, actual, normalize) => {
+    if (actual === void 0 || actual === null || expected === void 0) {
+      missing ??= field;
+      return void 0;
+    }
+    try {
+      const left = normalize ? normalize(expected) : expected;
+      const right = normalize ? normalize(actual) : actual;
+      if (left !== right) {
+        return {
+          matches: false,
+          evidence: "conflict",
+          reason: `${field} differs from the sent input`
+        };
+      }
+    } catch {
+      missing ??= field;
+    }
+    return void 0;
+  };
+  const checks = [
+    ["voucherType", sent.voucherType, found.voucherType],
+    ["salesPoint", sent.salesPoint, found.salesPoint],
+    ["number", number, found.voucherNumber, normalizeVoucherNumber],
+    [
+      "date",
+      sent.voucherDate,
+      found.voucherDate,
+      (value) => normalizeWsfeDateInput(value, "date")
+    ],
+    ["concept", sent.concept, found.concept],
+    ["documentType", sent.documentType, found.documentType],
+    [
+      "documentNumber",
+      sent.documentNumber,
+      found.documentNumber,
+      normalizeDocument
+    ],
+    [
+      "receiverVatConditionId",
+      sent.receiverVatConditionId,
+      found.receiverVatConditionId
+    ],
+    ["currencyId", sent.currencyId, found.currencyId],
+    [
+      "exchangeRate",
+      sent.exchangeRate ?? (sent.currencyId === "PES" ? 1 : void 0),
+      found.exchangeRate,
+      (value) => serializeArcaExchangeRate(value, "exchangeRate")
+    ]
+  ];
+  for (const field of [
+    "totalAmount",
+    "netAmount",
+    "vatAmount",
+    "exemptAmount",
+    "nonTaxableAmount",
+    "taxAmount"
+  ]) {
+    checks.push([
+      field,
+      sent[field],
+      found[field],
+      (value) => normalizeArcaAmountToMinorUnits(value, field)
+    ]);
+  }
+  if (sent.concept === 2 || sent.concept === 3) {
+    for (const field of [
+      "serviceStartDate",
+      "serviceEndDate",
+      "paymentDueDate"
+    ]) {
+      checks.push([
+        field,
+        sent[field],
+        found[field],
+        (value) => normalizeWsfeDateInput(value, field)
+      ]);
+    }
+  }
+  for (const check of checks) {
+    const result = compare(...check);
+    if (result) {
+      return result;
+    }
+  }
+  const rates = compareVatRates(sent.vatRates ?? [], found.vatRates);
+  if (!rates.matches) {
+    if (rates.evidence === "conflict") {
+      return rates;
+    }
+    missing ??= rates.reason;
+  }
+  if (sent.associatedVouchers?.length) {
+    if (!found.associatedVouchers) {
+      missing ??= "associatedVouchers";
+    } else if (associationIdentity(sent.associatedVouchers) !== associationIdentity(found.associatedVouchers)) {
+      return {
+        matches: false,
+        evidence: "conflict",
+        reason: "associatedVouchers differ from the sent input"
+      };
+    }
+  }
+  missing ??= incompleteAuthorization(sent, found);
+  return missing ? {
+    matches: false,
+    evidence: "incomplete",
+    reason: `Cannot verify ${missing}`
+  } : { matches: true };
+}
+function incompleteAuthorization(sent, found) {
+  let missing;
+  if (sent.concept !== 1 && sent.concept !== 2 && sent.concept !== 3) {
+    missing ??= "unsupported concept";
+  }
+  for (const field of [
+    "taxes",
+    "associatedPeriod",
+    "optionalFields",
+    "buyers",
+    "activities",
+    "sameCurrencyForeignCancellation"
+  ]) {
+    const value = sent[field];
+    if (value !== void 0 && (!Array.isArray(value) || value.length > 0)) {
+      missing ??= `unsupported exact field ${field}`;
+    }
+  }
+  if (!(found.result === "A" || found.result === "O")) {
+    missing ??= "authorized result";
+  }
+  if (!found.cae?.trim()) {
+    missing ??= "cae";
+  }
+  if (!found.caeExpiry?.trim()) {
+    missing ??= "caeExpiry";
+  }
+  return missing;
+}
+function normalizeVoucherNumber(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 99999999) {
+    throw new Error("Invalid voucher number");
+  }
+  return value;
+}
+function normalizeDocument(value) {
+  const text = String(value);
+  if (!/^\d+$/.test(text)) {
+    throw new Error("Invalid document number");
+  }
+  return BigInt(text);
+}
+function compareVatRates(expected, actual) {
+  if (actual === void 0) {
+    return expected.length === 0 ? { matches: true } : { matches: false, evidence: "incomplete", reason: "vatRates" };
+  }
+  if (actual.length !== expected.length || new Set(actual.map((rate) => rate.id)).size !== actual.length) {
+    return {
+      matches: false,
+      evidence: "conflict",
+      reason: "vatRates ids differ from the sent input"
+    };
+  }
+  for (const rate of expected) {
+    const found = actual.find((item) => item.id === rate.id);
+    if (!found) {
+      return {
+        matches: false,
+        evidence: "conflict",
+        reason: `vatRates id ${rate.id} differs from the sent input`
+      };
+    }
+    for (const field of ["baseAmount", "amount"]) {
+      try {
+        if (normalizeArcaAmountToMinorUnits(rate[field], field) !== normalizeArcaAmountToMinorUnits(found[field], field)) {
+          return {
+            matches: false,
+            evidence: "conflict",
+            reason: `vatRates[${rate.id}].${field} differs from the sent input`
+          };
+        }
+      } catch {
+        return {
+          matches: false,
+          evidence: "incomplete",
+          reason: `vatRates[${rate.id}].${field}`
+        };
+      }
+    }
+  }
+  return { matches: true };
+}
+function toVoucherSummary(found) {
+  const summary = { number: found.voucherNumber };
+  for (const field of [
+    "salesPoint",
+    "voucherType",
+    "concept",
+    "documentType",
+    "documentNumber",
+    "receiverVatConditionId",
+    "currencyId",
+    "exchangeRate",
+    "totalAmount",
+    "netAmount",
+    "vatAmount",
+    "exemptAmount",
+    "nonTaxableAmount",
+    "taxAmount",
+    "serviceStartDate",
+    "serviceEndDate",
+    "paymentDueDate",
+    "result",
+    "cae",
+    "caeExpiry"
+  ]) {
+    if (found[field] !== void 0) {
+      Object.assign(summary, { [field]: found[field] });
+    }
+  }
+  if (found.voucherDate !== void 0) {
+    summary.date = found.voucherDate;
+  }
+  if (found.vatRates !== void 0) {
+    summary.vatRates = found.vatRates.map(({ id, baseAmount, amount }) => ({
+      id,
+      baseAmount,
+      amount
+    }));
+  }
+  return summary;
+}
+function associationIdentity(vouchers) {
+  return JSON.stringify(
+    vouchers.map(({ type, salesPoint, number }) => `${type}:${salesPoint}:${number}`).sort()
+  );
+}
+
+// src/services/vouchers.ts
+function createVouchersService(wsfe, context) {
+  return {
+    cancel: async (target, options) => {
+      const result = await cancelInvoice(wsfe, target, options ?? {}, context);
+      return result;
+    },
+    issue: async (input, options) => {
+      const result = await issueInvoice(
+        wsfe,
+        input,
+        options === void 0 ? {} : options,
+        context
+      );
+      return result;
+    }
+  };
+}
+async function issueInvoice(wsfe, input, options, context) {
+  validateOptions(options);
+  validateKeyStore(options, context);
+  const prepared = deriveWsfeInvoice(input);
+  return await runOperation(
+    wsfe,
+    "issue",
+    input,
+    () => Promise.resolve(prepared),
+    options,
+    context,
+    prepared.amounts
+  );
+}
+async function runOperation(wsfe, operation, input, prepare, options, context, replayAmounts) {
+  const store = context?.store;
+  if (options.idempotencyKey === void 0 || !store || !context) {
+    return runAuthorization(wsfe, await prepare(), options);
+  }
+  const key = attemptKey(
+    context.environment,
+    context.taxId,
+    options.idempotencyKey
+  );
+  const representedTaxId = options.representedTaxId === void 0 ? void 0 : String(options.representedTaxId);
+  const inputHash = canonicalHash({ input, representedTaxId });
+  const existing = await storeCall(() => store.get(key));
+  if (existing !== null) {
+    return replay(existing);
+  }
+  const prepared = await prepare();
+  const number = await nextNumber(wsfe, prepared.data, options);
+  const record = {
+    v: 1,
+    operation,
+    representedTaxId,
+    inputHash,
+    number,
+    salesPoint: prepared.data.salesPoint,
+    voucherType: prepared.data.voucherType,
+    sent: prepared.data,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (await storeCall(() => store.add(key, JSON.stringify(record)))) {
+    return runAuthorization(wsfe, prepared, options, number);
+  }
+  const winner = await storeCall(() => store.get(key));
+  if (winner === null) {
+    throw new ArcaConfigurationError(
+      "ARCA reservation disappeared after atomic creation lost."
+    );
+  }
+  return replay(winner);
+  function replay(json) {
+    const stored = readRecord(json);
+    if (stored.operation !== operation || stored.inputHash !== inputHash || stored.representedTaxId !== representedTaxId) {
+      throw new ArcaInputError(
+        "The idempotency key was already used with different input or operation.",
+        {
+          code: "ARCA_INPUT_IDEMPOTENCY_MISMATCH",
+          field: "options.idempotencyKey"
+        }
+      );
+    }
+    return runAuthorization(
+      wsfe,
+      {
+        ...preparedFromRecord(stored),
+        ...replayAmounts ? { amounts: replayAmounts } : {}
+      },
+      options,
+      stored.number,
+      true
+    );
+  }
+}
+function validateKeyStore(options, context) {
+  if (options.idempotencyKey === void 0) {
+    return;
+  }
+  if (typeof options.idempotencyKey !== "string" || options.idempotencyKey.length < 1 || options.idempotencyKey.length > 255) {
+    throw new ArcaInputError(
+      "idempotencyKey must contain 1 to 255 characters.",
+      { code: "ARCA_INPUT_INVALID_VALUE", field: "options.idempotencyKey" }
+    );
+  }
+  if (!context?.store) {
+    throw new ArcaConfigurationError(
+      'idempotencyKey requires a store. Add import { createPostgresStore } from "facturas"; and store: createPostgresStore({ query }) to createArcaClient().'
+    );
+  }
+}
+function readRecord(json) {
+  try {
+    const record = JSON.parse(json);
+    if (!record || record.v !== 1 || !["issue", "cancel"].includes(record.operation) || typeof record.inputHash !== "string" || !record.sent || !Number.isSafeInteger(record.number) || record.number < 1 || record.number > 99999999 || record.sent.salesPoint !== record.salesPoint || record.sent.voucherType !== record.voucherType) {
+      throw new Error("Invalid reservation structure");
+    }
+    normalizeWsfeVoucherInput(record.sent);
+    return record;
+  } catch (cause) {
+    throw new ArcaConfigurationError(
+      "Invalid ARCA reservation record; preserve it for reconciliation.",
+      { cause }
+    );
+  }
+}
+function preparedFromRecord(record) {
+  const sentTotal = Number(
+    normalizeArcaAmountToMinorUnits(record.sent.totalAmount, "totalAmount")
+  );
+  return {
+    data: record.sent,
+    voucherClass: [1, 3].includes(record.voucherType) ? "A" : [6, 8].includes(record.voucherType) ? "B" : "C",
+    amounts: { computedTotal: sentTotal, sentTotal, vatAdjustment: 0 }
+  };
+}
+async function nextNumber(wsfe, data, options) {
+  const number = await wsfe.getNextVoucherNumber({
+    representedTaxId: options.representedTaxId,
+    forceRefresh: options.forceRefresh,
+    salesPoint: data.salesPoint,
+    voucherType: data.voucherType
+  });
+  if (!Number.isSafeInteger(number) || number < 1 || number > 99999999) {
+    throw new ArcaServiceError(
+      "WSFE returned an invalid next voucher number.",
+      { service: "wsfe", operation: "FECompUltimoAutorizado" }
+    );
+  }
+  return number;
+}
+async function runAuthorization(wsfe, { data, voucherClass, amounts }, options, reservedNumber, replay = false) {
+  const auth = {
+    representedTaxId: options.representedTaxId,
+    forceRefresh: options.forceRefresh
+  };
+  const includeRaw = options.include?.raw === true;
+  const includeExact = options.include?.exactInput === true;
+  const number = reservedNumber ?? await nextNumber(wsfe, data, options);
+  const attempted = {
+    salesPoint: data.salesPoint,
+    voucherType: data.voucherType,
+    number
+  };
+  const exact = includeExact ? { sent: data } : {};
+  const voucher = (cae, caeExpiry) => ({
+    ...attempted,
+    voucherClass,
+    date: data.voucherDate,
+    cae,
+    caeExpiry,
+    amounts
+  });
+  const recovery = { wsfe, auth, data, attempted, includeRaw, exact, voucher };
+  if (replay) {
+    const attempt2 = replayEvidence();
+    let lookup;
+    try {
+      lookup = await wsfe.lookupVoucher({ ...auth, ...attempted });
+    } catch (error) {
+      return {
+        kind: "indeterminate",
+        attempted,
+        attempt: attempt2,
+        lookup: { kind: "failed", error: toArcaSafeErrorMetadata(error) }
+      };
+    }
+    if (lookup.kind === "found") {
+      return recoverInvoice({ ...recovery, attempt: attempt2, lookup });
+    }
+  }
+  const authorization = await wsfe.issue({
+    ...auth,
+    data,
+    voucherNumber: number
+  });
+  if (authorization.kind === "authorized" && authorization.caeExpiry && authorization.voucherNumber === number) {
+    return {
+      kind: "authorized",
+      recoveredByMatch: false,
+      voucher: voucher(authorization.cae, authorization.caeExpiry),
+      authorization: projectEvidence(authorization, includeRaw),
+      ...exact
+    };
+  }
+  if (authorization.kind === "rejected") {
+    if (options.idempotencyKey !== void 0 && [...authorization.errors, ...authorization.observations].some(
+      (issue) => issue.code === "10016"
+    )) {
+      const recovered = await recoverInvoice({
+        ...recovery,
+        attempt: projectEvidence(
+          {
+            ...authorization,
+            kind: "indeterminate",
+            reason: "contradictory_response"
+          },
+          includeRaw
+        )
+      });
+      if (recovered.kind === "authorized" || recovered.kind === "conflict") {
+        return recovered;
+      }
+    }
+    return {
+      kind: "rejected",
+      attempted,
+      issues: [...authorization.errors, ...authorization.observations].map(
+        projectIssue
+      ),
+      authorization: projectEvidence(authorization, includeRaw)
+    };
+  }
+  const uncertain = authorization.kind === "indeterminate" ? authorization : {
+    ...authorization,
+    kind: "indeterminate",
+    reason: authorization.voucherNumber === number ? "incomplete_response" : "contradictory_response"
+  };
+  const attempt = projectEvidence(uncertain, includeRaw);
+  return recoverInvoice({
+    wsfe,
+    auth,
+    data,
+    attempted,
+    attempt,
+    includeRaw,
+    exact,
+    voucher
+  });
+}
+async function recoverInvoice({
+  wsfe,
+  auth,
+  data,
+  attempted,
+  attempt,
+  includeRaw,
+  exact,
+  voucher,
+  lookup: suppliedLookup
+}) {
+  let lookup;
+  try {
+    lookup = suppliedLookup ?? await wsfe.lookupVoucher({ ...auth, ...attempted });
+  } catch (error) {
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: { kind: "failed", error: toArcaSafeErrorMetadata(error) }
+    };
+  }
+  const raw = includeRaw ? { raw: lookup.raw } : {};
+  if (lookup.kind === "not_found") {
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: { kind: "not_found", ...raw }
+    };
+  }
+  const matched = matchWsfeVoucherIdentity(
+    data,
+    attempted.number,
+    lookup.voucher
+  );
+  if (!matched.matches) {
+    if (matched.evidence === "conflict") {
+      return {
+        kind: "conflict",
+        attempted,
+        attempt,
+        found: { ...toVoucherSummary(lookup.voucher), ...raw },
+        reason: `${matched.reason}. Configure a store and pass idempotencyKey for retries.`
+      };
+    }
+    return {
+      kind: "indeterminate",
+      attempted,
+      attempt,
+      lookup: { kind: "incomplete", reason: matched.reason, ...raw }
+    };
+  }
+  return {
+    kind: "authorized",
+    recoveredByMatch: true,
+    voucher: voucher(
+      lookup.voucher.cae,
+      lookup.voucher.caeExpiry
+    ),
+    attempt,
+    lookup: { ...toVoucherSummary(lookup.voucher), ...raw },
+    ...exact
+  };
+}
+function projectIssue(issue) {
+  return {
+    service: issue.service,
+    operation: issue.operation,
+    source: issue.source,
+    category: issue.category,
+    message: issue.message,
+    ...issue.code === void 0 ? {} : { code: issue.code },
+    ...issue.resultLevel === void 0 ? {} : { resultLevel: issue.resultLevel }
+  };
+}
+function projectEvidence(evidence, includeRaw) {
+  const base = {
+    kind: evidence.kind,
+    service: evidence.service,
+    operation: evidence.operation,
+    results: {
+      ...evidence.results.header === void 0 ? {} : { header: evidence.results.header },
+      ...evidence.results.detail === void 0 ? {} : { detail: evidence.results.detail },
+      ...evidence.results.operation === void 0 ? {} : { operation: evidence.results.operation }
+    },
+    errors: evidence.errors.map(projectIssue),
+    observations: evidence.observations.map(projectIssue),
+    ...includeRaw && evidence.raw !== void 0 ? { raw: evidence.raw } : {}
+  };
+  const projected = { ...base };
+  for (const field of [
+    "result",
+    "resultLevel",
+    "cae",
+    "caeExpiry",
+    "voucherNumber",
+    "reason"
+  ]) {
+    if (field in evidence && evidence[field] !== void 0) {
+      projected[field] = evidence[field];
+    }
+  }
+  if (evidence.kind === "indeterminate" && evidence.authentication) {
+    const { code, reason, providerCode } = evidence.authentication;
+    projected.authentication = {
+      code,
+      reason,
+      ...providerCode === void 0 ? {} : { providerCode }
+    };
+  }
+  return projected;
+}
+function validateOptions(options) {
+  assertIssueObject(options, "options");
+  assertIssueKeys(
+    options,
+    ["representedTaxId", "forceRefresh", "include", "idempotencyKey"],
+    "options"
+  );
+  if (options.representedTaxId !== void 0) {
+    issueDocumentNumber(
+      options.representedTaxId,
+      "options.representedTaxId",
+      11,
+      11
+    );
+  }
+  if (options.forceRefresh !== void 0 && typeof options.forceRefresh !== "boolean") {
+    throw new ArcaInputError("options.forceRefresh must be a boolean.", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "options.forceRefresh"
+    });
+  }
+  if (options.include !== void 0) {
+    assertIssueObject(options.include, "options.include");
+    assertIssueKeys(options.include, ["raw", "exactInput"], "options.include");
+    for (const field of ["raw", "exactInput"]) {
+      if (options.include[field] !== void 0 && typeof options.include[field] !== "boolean") {
+        throw new ArcaInputError(
+          `options.include.${field} must be a boolean.`,
+          {
+            code: "ARCA_INPUT_INVALID_VALUE",
+            field: `options.include.${field}`
+          }
+        );
+      }
+    }
+  }
+}
+function replayEvidence() {
+  return {
+    kind: "indeterminate",
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    reason: "incomplete_response",
+    results: {},
+    errors: [],
+    observations: []
+  };
+}
+async function cancelInvoice(wsfe, target, options, context) {
+  assertIssueObject(options, "options");
+  const { date, ...issueOptions } = options;
+  validateOptions(issueOptions);
+  validateKeyStore(issueOptions, context);
+  assertIssueObject(target, "target");
+  for (const [field, max] of [
+    ["salesPoint", 99999],
+    ["voucherType", 999],
+    ["number", 99999999]
+  ]) {
+    if (!Number.isSafeInteger(target[field]) || target[field] < 1 || target[field] > max) {
+      throw new ArcaInputError(`Invalid cancel target ${field}.`, {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field
+      });
+    }
+  }
+  if (![1, 6, 11].includes(target.voucherType)) {
+    throw new ArcaInputError(
+      "cancel requires an invoice of type 1, 6 or 11; use wsfe.issue() for exact control.",
+      { code: "ARCA_INPUT_INVALID_VALUE" }
+    );
+  }
+  if (date !== void 0) {
+    normalizeWsfeDateInput(date, "date");
+  }
+  return await runOperation(
+    wsfe,
+    "cancel",
+    { target, date },
+    async () => {
+      const original = await wsfe.lookupVoucher({
+        representedTaxId: issueOptions.representedTaxId,
+        forceRefresh: issueOptions.forceRefresh,
+        salesPoint: target.salesPoint,
+        voucherType: target.voucherType,
+        number: target.number
+      });
+      if (original.kind === "not_found") {
+        throw new ArcaInputError("original voucher not found", {
+          code: "ARCA_INPUT_INVALID_VALUE"
+        });
+      }
+      if (original.voucher.salesPoint !== target.salesPoint || original.voucher.voucherType !== target.voucherType || original.voucher.voucherNumber !== target.number) {
+        throw new ArcaInputError(
+          "Original lookup coordinates do not match the cancel target.",
+          { code: "ARCA_INPUT_INVALID_VALUE" }
+        );
+      }
+      return deriveWsfeCancellation(original.voucher, date);
+    },
+    issueOptions,
+    context
+  );
+}
+
 // src/internal/http.ts
 import https from "https";
 var defaultAgent = new https.Agent({
@@ -695,7 +1804,7 @@ function createSoapTransport(options) {
 }
 
 // src/wsaa/index.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import forge from "node-forge";
 
 // src/wsaa/session-store.ts
@@ -929,7 +2038,7 @@ function buildWsaaSessionKey(config, service) {
   };
 }
 function getCertificateFingerprint(config) {
-  return createHash("sha256").update(config.certificatePem).digest("hex");
+  return createHash2("sha256").update(config.certificatePem).digest("hex");
 }
 function getCachedCredentials(cache, cacheKey) {
   const localCached = cache.get(cacheKey);
@@ -1120,10 +2229,40 @@ function parseLoginTicketResponse(xml) {
   };
 }
 
+// src/wsaa/store-adapter.ts
+function createWsaaStoreAdapter(store) {
+  const key = (value) => `arca:v1:wsaa:${serializeWsaaSessionKey(value)}`;
+  const remove = store.delete?.bind(store);
+  const lock = store.withLock?.bind(store);
+  return {
+    get: (value) => storeCall(async () => {
+      const json = await store.get(key(value));
+      if (json === null) {
+        return null;
+      }
+      const credentials = JSON.parse(json);
+      return credentials && typeof credentials.token === "string" && typeof credentials.sign === "string" && isWsaaCredentialValid(credentials) ? credentials : null;
+    }),
+    set: (value, credentials) => storeCall(() => store.set(key(value), JSON.stringify(credentials))),
+    ...remove ? {
+      delete: (value) => storeCall(() => remove(key(value)))
+    } : {},
+    ...lock ? {
+      withLock: (value, fn) => lock(key(value), fn)
+    } : {}
+  };
+}
+
 // src/client.ts
-function createArcaClient(config) {
-  assertArcaClientConfig(config);
-  const normalizedConfig = normalizeArcaClientConfig(config);
+function createArcaClient(config = {}) {
+  const discovered = discoverArcaClientConfig(config);
+  assertArcaClientConfig(discovered);
+  const normalizedConfig = normalizeArcaClientConfig(discovered);
+  if (normalizedConfig.store && !normalizedConfig.wsaaSessionStore) {
+    normalizedConfig.wsaaSessionStore = createWsaaStoreAdapter(
+      normalizedConfig.store
+    );
+  }
   const logger = createArcaLogger(normalizedConfig.logger);
   const auth = createWsaaAuthModule({ config: normalizedConfig, logger });
   const soap = createSoapTransport({ config: normalizedConfig, logger });
@@ -1134,16 +2273,184 @@ function createArcaClient(config) {
     retries: normalizedConfig.retries,
     retryDelay: normalizedConfig.retryDelay
   });
+  const wsfe = createWsfeService({ config: normalizedConfig, auth, soap });
+  const vouchers = createVouchersService(wsfe, normalizedConfig);
   return {
     config: publicConfig,
-    wsfe: createWsfeService({ config: normalizedConfig, auth, soap }),
+    issue: vouchers.issue,
+    cancel: vouchers.cancel,
+    wsfe,
     wsmtxca: createWsmtxcaService({ config: normalizedConfig, auth, soap }),
     padron: createPadronService({ config: normalizedConfig, auth, soap })
   };
 }
+
+// src/store/file.ts
+import { createHash as createHash3, randomUUID } from "crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+function createFileStore(directory) {
+  const path = (key) => join(directory, createHash3("sha256").update(key).digest("hex"));
+  const ensure = () => mkdir(directory, { recursive: true, mode: 448 });
+  return {
+    get: (key) => storeCall(async () => {
+      try {
+        return await readFile(path(key), "utf8");
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return null;
+        }
+        throw error;
+      }
+    }),
+    set: (key, value) => storeCall(async () => {
+      await ensure();
+      const temporary = `${path(key)}.${randomUUID()}.tmp`;
+      try {
+        await writeFile(temporary, value, { mode: 384, flag: "wx" });
+        await rename(temporary, path(key));
+      } finally {
+        await unlink(temporary).catch(() => void 0);
+      }
+    }),
+    add: (key, value) => storeCall(async () => {
+      await ensure();
+      try {
+        await writeFile(path(key), value, { flag: "wx", mode: 384 });
+        return true;
+      } catch (error) {
+        if (error.code === "EEXIST") {
+          return false;
+        }
+        throw error;
+      }
+    }),
+    delete: (key) => storeCall(async () => {
+      try {
+        await unlink(path(key));
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    })
+  };
+}
+
+// src/store/memory.ts
+function createMemoryStore() {
+  const values = /* @__PURE__ */ new Map();
+  const locks = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => Promise.resolve(values.get(key) ?? null),
+    set(key, value) {
+      values.set(key, value);
+      return Promise.resolve();
+    },
+    add(key, value) {
+      if (values.has(key)) {
+        return Promise.resolve(false);
+      }
+      values.set(key, value);
+      return Promise.resolve(true);
+    },
+    delete(key) {
+      values.delete(key);
+      return Promise.resolve();
+    },
+    async withLock(key, fn) {
+      const previous = locks.get(key) ?? Promise.resolve();
+      let release = () => void 0;
+      const current = new Promise((resolve) => {
+        release = resolve;
+      });
+      const queued = previous.catch(() => void 0).then(() => current);
+      locks.set(key, queued);
+      await previous.catch(() => void 0);
+      try {
+        return await fn();
+      } finally {
+        release();
+        if (locks.get(key) === queued) {
+          locks.delete(key);
+        }
+      }
+    }
+  };
+}
+
+// src/store/postgres.ts
+function createPostgresStore({
+  query,
+  table = "arca_store"
+}) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+    throw new ArcaConfigurationError("Invalid ARCA store table identifier.");
+  }
+  const name = `"${table}"`;
+  const run = (text, params) => storeCall(async () => {
+    const result = await query(text, params);
+    return Array.isArray(result) ? result : result.rows;
+  });
+  return {
+    async get(key) {
+      return (await run(`SELECT value FROM ${name} WHERE key = $1`, [key]))[0]?.value ?? null;
+    },
+    async set(key, value) {
+      await run(
+        `INSERT INTO ${name} (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now()`,
+        [key, value]
+      );
+    },
+    async add(key, value) {
+      return (await run(
+        `INSERT INTO ${name} (key, value) VALUES ($1, $2) ON CONFLICT DO NOTHING RETURNING key`,
+        [key, value]
+      )).length > 0;
+    },
+    async delete(key) {
+      await run(`DELETE FROM ${name} WHERE key = $1`, [key]);
+    }
+  };
+}
+
+// src/store/redis.ts
+function createRedisStore(client, options = {}) {
+  const flavor = options.flavor ?? (typeof client.call === "function" ? "ioredis" : "upstash");
+  if (flavor === "ioredis" && !client.call) {
+    throw new ArcaConfigurationError(
+      "ARCA Redis ioredis flavor requires client.call."
+    );
+  }
+  const upstashSet = client.set;
+  return {
+    get: (key) => storeCall(async () => {
+      const value = await client.get(key);
+      if (value === null) {
+        return null;
+      }
+      return typeof value === "string" ? value : JSON.stringify(value);
+    }),
+    set: (key, value) => storeCall(async () => {
+      await client.set(key, value);
+    }),
+    add: (key, value) => storeCall(
+      async () => (flavor === "ioredis" ? await client.call?.("SET", key, value, "NX") : await upstashSet.call(client, key, value, { nx: true })) === "OK"
+    ),
+    ...client.del ? {
+      delete: (key) => storeCall(async () => {
+        await client.del?.(key);
+      })
+    } : {}
+  };
+}
 export {
   ARCA_ENVIRONMENTS,
   ARCA_ENV_VARIABLES,
+  ARCA_FINAL_CONSUMER_IDENTIFICATION_THRESHOLD_MINOR_UNITS,
+  ARCA_INVOICE_CLASS_BY_ISSUER,
+  ARCA_ISSUER_CONDITION_IDS,
+  ARCA_RECEIVER_CONDITION_IDS,
   ArcaAuthenticationError,
   ArcaConfigurationError,
   ArcaError,
@@ -1157,11 +2464,17 @@ export {
   buildFacturaC,
   createArcaClient,
   createArcaClientConfigFromEnv,
+  createFileStore,
+  createMemoryStore,
   createMemoryWsaaSessionStore,
   createPadronService,
+  createPostgresStore,
+  createRedisStore,
   createWsfeService,
   createWsmtxcaService,
   isArcaAuthenticationError,
-  resolveArcaEnvironment
+  matchWsfeVoucherIdentity,
+  resolveArcaEnvironment,
+  toArcaSafeErrorMetadata
 };
 //# sourceMappingURL=index.mjs.map