facturas 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -1,16 +1,29 @@
 import {
   createPadronService
-} from "./chunk-EDY3PNKJ.mjs";
+} from "./chunk-NUV5RZPZ.mjs";
 import {
   buildFacturaB,
   buildFacturaC,
-  createWsfeService
-} from "./chunk-C55KOV5N.mjs";
-import "./chunk-VVY2LZIZ.mjs";
+  calculateWsfeAmounts,
+  createWsfeService,
+  normalizeArcaAmountToMinorUnits,
+  normalizeWsfeDateInput,
+  normalizeWsfeVoucherInput,
+  serializeArcaExchangeRate
+} from "./chunk-TOVSOJ3G.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-PKE4Z4GE.mjs";
-import "./chunk-IOKZX6CA.mjs";
+} from "./chunk-ZX4OOCML.mjs";
+import "./chunk-PPYGVNFA.mjs";
 import {
   ArcaAuthenticationError,
   ArcaConfigurationError,
@@ -22,8 +35,9 @@ import {
   ArcaTransportError,
   createResponseBodyDiagnostic,
   createSafeErrorDiagnostic,
-  isArcaAuthenticationError
-} from "./chunk-MBWOFO67.mjs";
+  isArcaAuthenticationError,
+  toArcaSafeErrorMetadata
+} from "./chunk-HUT3PFKF.mjs";
 
 // src/config.ts
 var ARCA_ENVIRONMENTS = ["production", "test"];
@@ -287,6 +301,686 @@ function defaultArcaLog(level, message, ...args) {
   method(message, ...args);
 }
 
+// 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 vouchers.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-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) {
+    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;
+  }
+  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) {
+    missing ??= "unsupported concept";
+  }
+  for (const field of [
+    "taxes",
+    "associatedVouchers",
+    "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;
+}
+
+// src/services/vouchers.ts
+var SERIALIZATION_NOTICE = "Serialize calls per (representedTaxId, salesPoint, voucherType). The SDK does not coordinate writers; uncoordinated calls collide on 10016. Servers and queues must persist attempts and use wsfe.authorizeVoucherOutcome().";
+function createVouchersService(wsfe) {
+  return {
+    issue: async (input, options) => {
+      const result = await issueInvoice(
+        wsfe,
+        input,
+        options === void 0 ? {} : options
+      );
+      return result;
+    }
+  };
+}
+async function issueInvoice(wsfe, input, options) {
+  validateOptions(options);
+  const { data, voucherClass, amounts } = deriveWsfeInvoice(input);
+  const auth = {
+    representedTaxId: options.representedTaxId,
+    forceRefresh: options.forceRefresh
+  };
+  const includeRaw = options.include?.raw === true;
+  const includeExact = options.include?.exactInput === true;
+  const number = await wsfe.getNextVoucherNumber({
+    ...auth,
+    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"
+      }
+    );
+  }
+  const attempted = {
+    salesPoint: data.salesPoint,
+    voucherType: data.voucherType,
+    number
+  };
+  const exact = includeExact ? { sent: data } : {};
+  const authorization = await wsfe.authorizeVoucherOutcome({
+    ...auth,
+    data,
+    voucherNumber: number
+  });
+  const voucher = (cae, caeExpiry) => ({
+    ...attempted,
+    voucherClass,
+    date: data.voucherDate,
+    cae,
+    caeExpiry,
+    amounts
+  });
+  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") {
+    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
+}) {
+  let lookup;
+  try {
+    lookup = 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}. ${SERIALIZATION_NOTICE}`
+      };
+    }
+    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"],
+    "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}`
+          }
+        );
+      }
+    }
+  }
+}
+
 // src/internal/http.ts
 import https from "https";
 var defaultAgent = new https.Agent({
@@ -1134,9 +1828,11 @@ function createArcaClient(config) {
     retries: normalizedConfig.retries,
     retryDelay: normalizedConfig.retryDelay
   });
+  const wsfe = createWsfeService({ config: normalizedConfig, auth, soap });
   return {
     config: publicConfig,
-    wsfe: createWsfeService({ config: normalizedConfig, auth, soap }),
+    wsfe,
+    vouchers: createVouchersService(wsfe),
     wsmtxca: createWsmtxcaService({ config: normalizedConfig, auth, soap }),
     padron: createPadronService({ config: normalizedConfig, auth, soap })
   };
@@ -1144,6 +1840,10 @@ function createArcaClient(config) {
 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,
@@ -1162,6 +1862,8 @@ export {
   createWsfeService,
   createWsmtxcaService,
   isArcaAuthenticationError,
-  resolveArcaEnvironment
+  matchWsfeVoucherIdentity,
+  resolveArcaEnvironment,
+  toArcaSafeErrorMetadata
 };
 //# sourceMappingURL=index.mjs.map