facturas 0.6.1 → 0.7.1

package/dist/chunk-OHHXHYLV.mjs

@@ -0,0 +1,1602 @@
+import {
+  ARCA_CURRENCY_IDS,
+  ARCA_VAT_RATES,
+  ARCA_VOUCHER_TYPES
+} from "./chunk-VVY2LZIZ.mjs";
+import {
+  classifyArcaAuthenticationError,
+  classifyArcaAuthenticationIssues,
+  createArcaAuthenticationErrorFromEvidence,
+  createArcaAuthenticationEvidence,
+  executeWithAuthenticationRecovery
+} from "./chunk-IOKZX6CA.mjs";
+import {
+  ArcaInputError,
+  ArcaInvalidSoapResponseError,
+  ArcaServiceError,
+  ArcaSoapFaultError,
+  ArcaTransportError
+} from "./chunk-MBWOFO67.mjs";
+
+// src/internal/decimal.ts
+var AMOUNT_SCALE = 100;
+var EXCHANGE_RATE_SCALE = 1e6;
+var EXCHANGE_RATE_SCALE_BIGINT = 1000000n;
+var PERCENTAGE_SCALE = 100;
+var MAX_ARCA_AMOUNT_MINOR_UNITS = 999999999999999n;
+var MAX_ARCA_EXCHANGE_RATE_SCALED = 9999999999n;
+var MAX_ARCA_PERCENTAGE_HUNDREDTHS = 99999n;
+var VAT_RATE_BASIS_POINTS = {
+  0: 0n,
+  2.5: 250n,
+  5: 500n,
+  10.5: 1050n,
+  21: 2100n,
+  27: 2700n
+};
+function normalizeArcaAmountToMinorUnits(value, field) {
+  return normalizeScaledNumber({
+    value,
+    field,
+    scale: AMOUNT_SCALE,
+    maximum: MAX_ARCA_AMOUNT_MINOR_UNITS,
+    expected: "a finite non-negative amount with at most 2 decimal places"
+  });
+}
+function serializeArcaAmount(value, field) {
+  return formatScaledInteger(normalizeArcaAmountToMinorUnits(value, field), 2);
+}
+function serializeArcaPercentage(value, field) {
+  const scaled = normalizeScaledNumber({
+    value,
+    field,
+    scale: PERCENTAGE_SCALE,
+    maximum: MAX_ARCA_PERCENTAGE_HUNDREDTHS,
+    expected: "a finite non-negative percentage with at most 2 decimal places"
+  });
+  return formatScaledInteger(scaled, 2);
+}
+function serializeArcaExchangeRate(value, field) {
+  const scaled = typeof value === "number" ? normalizeExchangeRateNumber(value, field) : normalizeExchangeRateString(value, field);
+  if (scaled <= 0n || scaled > MAX_ARCA_EXCHANGE_RATE_SCALED) {
+    throwInvalidExchangeRate(field);
+  }
+  return formatScaledInteger(scaled, 6, true);
+}
+function assertArcaMinorUnits(value, field) {
+  if (!(Number.isSafeInteger(value) && value >= 0)) {
+    throw new ArcaInputError(
+      `${field} must be a non-negative safe integer in currency minor units.`,
+      {
+        code: "ARCA_INPUT_INVALID_AMOUNT",
+        field,
+        expected: "a non-negative safe integer in currency minor units"
+      }
+    );
+  }
+  const minorUnits = BigInt(value);
+  if (minorUnits > MAX_ARCA_AMOUNT_MINOR_UNITS) {
+    throw new ArcaInputError(`${field} exceeds the WSFE amount limit.`, {
+      code: "ARCA_INPUT_INVALID_AMOUNT",
+      field,
+      expected: "at most 13 integer digits and 2 decimal places"
+    });
+  }
+  return minorUnits;
+}
+function arcaMinorUnitsToNumber(minorUnits, field) {
+  if (minorUnits < 0n || minorUnits > MAX_ARCA_AMOUNT_MINOR_UNITS) {
+    throw new ArcaInputError(`${field} exceeds the WSFE amount limit.`, {
+      code: "ARCA_INPUT_INVALID_AMOUNT",
+      field,
+      expected: "at most 13 integer digits and 2 decimal places"
+    });
+  }
+  return Number(formatScaledInteger(minorUnits, 2));
+}
+function calculateVatMinorUnits(taxableMinorUnits, vatRate, field) {
+  const basisPoints = VAT_RATE_BASIS_POINTS[vatRate];
+  if (basisPoints === void 0) {
+    throw new ArcaInputError(`${field} is not a supported VAT rate.`, {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field,
+      expected: "one of 0, 2.5, 5, 10.5, 21, or 27"
+    });
+  }
+  return roundHalfEvenRatio(taxableMinorUnits * basisPoints, 10000n);
+}
+function roundHalfEvenRatio(numerator, denominator) {
+  if (numerator < 0n || denominator <= 0n) {
+    throw new RangeError(
+      "roundHalfEvenRatio requires a non-negative numerator and a positive denominator."
+    );
+  }
+  const quotient = numerator / denominator;
+  const doubledRemainder = numerator % denominator * 2n;
+  if (doubledRemainder > denominator) {
+    return quotient + 1n;
+  }
+  if (doubledRemainder < denominator) {
+    return quotient;
+  }
+  return quotient % 2n === 0n ? quotient : quotient + 1n;
+}
+function isWithinArcaTolerance(actualMinorUnits, expectedMinorUnits, absoluteCentAllowance = 1) {
+  const difference = absoluteBigInt(actualMinorUnits - expectedMinorUnits);
+  if (difference <= BigInt(Math.max(1, absoluteCentAllowance))) {
+    return true;
+  }
+  const comparisonBase = absoluteBigInt(expectedMinorUnits);
+  return comparisonBase > 0n && difference * 10000n <= comparisonBase;
+}
+function normalizeScaledNumber({
+  value,
+  field,
+  scale,
+  maximum,
+  expected
+}) {
+  if (!(Number.isFinite(value) && value >= 0)) {
+    throw new ArcaInputError(`${field} must be ${expected}.`, {
+      code: "ARCA_INPUT_INVALID_AMOUNT",
+      field,
+      expected
+    });
+  }
+  const scaled = value * scale;
+  const nearestInteger = Math.round(scaled);
+  const representationTolerance = Math.max(
+    1e-9,
+    Math.abs(scaled) * Number.EPSILON * 4
+  );
+  if (Math.abs(scaled - nearestInteger) > representationTolerance) {
+    throw new ArcaInputError(
+      `${field} has more precision than its ARCA field allows.`,
+      {
+        code: "ARCA_INPUT_AMOUNT_PRECISION",
+        field,
+        expected
+      }
+    );
+  }
+  if (!Number.isSafeInteger(nearestInteger)) {
+    throw new ArcaInputError(`${field} exceeds the safely supported range.`, {
+      code: "ARCA_INPUT_INVALID_AMOUNT",
+      field,
+      expected
+    });
+  }
+  const normalized = BigInt(nearestInteger);
+  if (normalized > maximum) {
+    throw new ArcaInputError(`${field} exceeds the ARCA field limit.`, {
+      code: "ARCA_INPUT_INVALID_AMOUNT",
+      field,
+      expected
+    });
+  }
+  return normalized;
+}
+function normalizeExchangeRateNumber(value, field) {
+  if (!(Number.isFinite(value) && value > 0)) {
+    throwInvalidExchangeRate(field);
+  }
+  const scaled = value * EXCHANGE_RATE_SCALE;
+  const nearestInteger = Math.round(scaled);
+  const representationTolerance = Math.max(
+    1e-9,
+    Math.abs(scaled) * Number.EPSILON * 4
+  );
+  if (Math.abs(scaled - nearestInteger) > representationTolerance || !Number.isSafeInteger(nearestInteger)) {
+    throwInvalidExchangeRate(field);
+  }
+  return BigInt(nearestInteger);
+}
+function normalizeExchangeRateString(value, field) {
+  const match = value.match(/^(0|[1-9]\d{0,3})(?:\.(\d{1,6}))?$/);
+  if (!match) {
+    throwInvalidExchangeRate(field);
+  }
+  const [, integerPart, fractionPart = ""] = match;
+  return BigInt(integerPart) * EXCHANGE_RATE_SCALE_BIGINT + BigInt(fractionPart.padEnd(6, "0"));
+}
+function throwInvalidExchangeRate(field) {
+  throw new ArcaInputError(
+    `${field} must be a positive decimal with at most 4 integer and 6 fractional digits.`,
+    {
+      code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
+      field,
+      expected: "a positive decimal with up to 4 integer and 6 fractional digits"
+    }
+  );
+}
+function formatScaledInteger(value, fractionDigits, trimTrailingZeros = false) {
+  const scale = 10n ** BigInt(fractionDigits);
+  const integerPart = value / scale;
+  const fractionPart = (value % scale).toString().padStart(fractionDigits, "0");
+  if (trimTrailingZeros) {
+    const trimmedFraction = fractionPart.replace(/0+$/, "");
+    return trimmedFraction.length === 0 ? integerPart.toString() : `${integerPart}.${trimmedFraction}`;
+  }
+  return `${integerPart}.${fractionPart}`;
+}
+function absoluteBigInt(value) {
+  return value < 0n ? -value : value;
+}
+
+// src/services/wsfe.ts
+function createWsfeService(options) {
+  async function executeWsfeAuthenticatedRawOperation(operation, input, body = {}, retries) {
+    const auth = await options.auth.login("wsfe", {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh
+    });
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      ...retries === void 0 ? {} : { retries },
+      body: {
+        Auth: createWsfeAuth(
+          input.representedTaxId ?? options.config.taxId,
+          auth.token,
+          auth.sign
+        ),
+        ...body
+      }
+    });
+    return unwrapWsfeOperationEnvelope(operation, response.result);
+  }
+  function executeWsfeAuthenticatedOperation(operation, input, body = {}) {
+    return executeWithAuthenticationRecovery({
+      service: "wsfe",
+      operation,
+      forceRefresh: input.forceRefresh,
+      async execute(forceRefresh) {
+        const result = await executeWsfeAuthenticatedRawOperation(
+          operation,
+          { representedTaxId: input.representedTaxId, forceRefresh },
+          body
+        );
+        throwForWsfeOperationErrors(operation, result);
+        return result;
+      }
+    });
+  }
+  async function executeWsfeOperation(operation, body = {}) {
+    const response = await options.soap.execute({
+      service: "wsfe",
+      operation,
+      body
+    });
+    const result = unwrapWsfeOperationEnvelope(operation, response.result);
+    throwForWsfeOperationErrors(operation, result);
+    return result;
+  }
+  async function getNextVoucherNumber({
+    representedTaxId,
+    salesPoint,
+    voucherType,
+    forceRefresh
+  }) {
+    const result = await executeWsfeAuthenticatedOperation(
+      "FECompUltimoAutorizado",
+      {
+        representedTaxId,
+        forceRefresh
+      },
+      {
+        PtoVta: salesPoint,
+        CbteTipo: voucherType
+      }
+    );
+    return Number(result.CbteNro ?? 0) + 1;
+  }
+  async function getWsfeCatalog(operation, resultKey, input) {
+    const result = await executeWsfeAuthenticatedOperation(operation, {
+      representedTaxId: input.representedTaxId,
+      forceRefresh: input.forceRefresh
+    });
+    return getWsfeResultEntries(result, resultKey).map(mapWsfeCatalogEntry);
+  }
+  function authorizeVoucher({
+    representedTaxId,
+    data,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const normalizedInput = normalizeWsfeVoucherInput(data);
+    return authorizeNormalizedVoucher({
+      representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
+      forceRefresh
+    });
+  }
+  function authorizeVoucherOutcome({
+    representedTaxId,
+    data,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const normalizedInput = normalizeWsfeVoucherInput(data);
+    return executeWsfeAuthorization({
+      representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
+      forceRefresh
+    }).then(({ outcome }) => outcome);
+  }
+  function authorizeNormalizedVoucher({
+    representedTaxId,
+    data: normalizedInput,
+    voucherNumber,
+    forceRefresh,
+    allowAuthenticationRecovery
+  }) {
+    return executeWithAuthenticationRecovery({
+      service: "wsfe",
+      operation: "FECAESolicitar",
+      forceRefresh,
+      allowRetry: allowAuthenticationRecovery,
+      execute: (attemptForceRefresh) => authorizeNormalizedVoucherOnce({
+        representedTaxId,
+        data: normalizedInput,
+        voucherNumber,
+        forceRefresh: attemptForceRefresh
+      })
+    });
+  }
+  async function authorizeNormalizedVoucherOnce({
+    representedTaxId,
+    data: normalizedInput,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const execution = await executeWsfeAuthorization({
+      representedTaxId,
+      data: normalizedInput,
+      voucherNumber,
+      forceRefresh
+    });
+    if (execution.error) {
+      throw execution.error;
+    }
+    if (execution.outcome.kind !== "authorized") {
+      throw createWsfeOutcomeError(execution.outcome);
+    }
+    const { cae, caeExpiry, raw } = execution.outcome;
+    if (!(caeExpiry && raw)) {
+      throw new ArcaServiceError("WSFE did not return CAE authorization data", {
+        service: "wsfe",
+        operation: "FECAESolicitar",
+        result: execution.outcome.result,
+        resultLevel: execution.outcome.resultLevel,
+        results: execution.outcome.results,
+        cae,
+        issues: [
+          ...execution.outcome.errors,
+          ...execution.outcome.observations
+        ]
+      });
+    }
+    return {
+      cae,
+      caeExpiry,
+      voucherNumber,
+      raw
+    };
+  }
+  async function executeWsfeAuthorization({
+    representedTaxId,
+    data: normalizedInput,
+    voucherNumber,
+    forceRefresh
+  }) {
+    const requestData = mapWsfeVoucherInput(normalizedInput, voucherNumber);
+    try {
+      const result = await executeWsfeAuthenticatedRawOperation(
+        "FECAESolicitar",
+        { representedTaxId, forceRefresh },
+        {
+          FeCAEReq: {
+            FeCabReq: {
+              CantReg: 1,
+              PtoVta: normalizedInput.salesPoint,
+              CbteTipo: normalizedInput.voucherType
+            },
+            FeDetReq: {
+              FECAEDetRequest: requestData
+            }
+          }
+        },
+        0
+      );
+      return {
+        outcome: classifyWsfeAuthorization(result, voucherNumber)
+      };
+    } catch (error) {
+      return {
+        outcome: createWsfeIndeterminateOutcome(error),
+        error
+      };
+    }
+  }
+  function lookupVoucher({
+    representedTaxId,
+    number,
+    salesPoint,
+    voucherType,
+    forceRefresh
+  }) {
+    return executeWithAuthenticationRecovery({
+      service: "wsfe",
+      operation: "FECompConsultar",
+      forceRefresh,
+      execute: (attemptForceRefresh) => lookupVoucherOnce({
+        representedTaxId,
+        number,
+        salesPoint,
+        voucherType,
+        forceRefresh: attemptForceRefresh
+      })
+    });
+  }
+  async function lookupVoucherOnce({
+    representedTaxId,
+    number,
+    salesPoint,
+    voucherType,
+    forceRefresh
+  }) {
+    const operation = "FECompConsultar";
+    const result = await executeWsfeAuthenticatedRawOperation(
+      operation,
+      { representedTaxId, forceRefresh },
+      {
+        FeCompConsReq: {
+          CbteNro: number,
+          PtoVta: salesPoint,
+          CbteTipo: voucherType
+        }
+      }
+    );
+    const errors = extractWsfeGlobalIssues(result, operation);
+    if (errors.length > 0 && errors.every((issue) => issue.code === "602")) {
+      return {
+        kind: "not_found",
+        service: "wsfe",
+        operation,
+        errors,
+        observations: [],
+        raw: result
+      };
+    }
+    if (errors.length > 0) {
+      throw createWsfeServiceError(operation, errors);
+    }
+    const raw = toWsfeRecord(result.ResultGet);
+    if (!raw) {
+      throw new ArcaServiceError("WSFE did not return the consulted voucher", {
+        service: "wsfe",
+        operation
+      });
+    }
+    return {
+      kind: "found",
+      service: "wsfe",
+      operation,
+      voucher: mapWsfeVoucherInfo(raw),
+      observations: [],
+      raw: result
+    };
+  }
+  return {
+    authorizeVoucherOutcome,
+    authorizeVoucher,
+    async createNextVoucher({ representedTaxId, data, forceRefresh }) {
+      const normalizedInput = normalizeWsfeVoucherInput(data);
+      const voucherNumber = await getNextVoucherNumber({
+        representedTaxId,
+        salesPoint: normalizedInput.salesPoint,
+        voucherType: normalizedInput.voucherType,
+        forceRefresh
+      });
+      return authorizeNormalizedVoucher({
+        representedTaxId,
+        data: normalizedInput,
+        voucherNumber,
+        allowAuthenticationRecovery: forceRefresh !== true
+      });
+    },
+    getNextVoucherNumber,
+    getLastVoucher(input) {
+      return getNextVoucherNumber(input);
+    },
+    async getSalesPoints({ representedTaxId, forceRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetPtosVenta",
+        {
+          representedTaxId,
+          forceRefresh
+        }
+      );
+      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, forceRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetTiposMonedas",
+        {
+          representedTaxId,
+          forceRefresh
+        }
+      );
+      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, forceRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetActividades",
+        {
+          representedTaxId,
+          forceRefresh
+        }
+      );
+      return getWsfeResultEntries(result, "ActividadesTipo").map(
+        mapWsfeActivityType
+      );
+    },
+    async getReceiverVatConditions({
+      representedTaxId,
+      voucherClass,
+      forceRefresh
+    }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCondicionIvaReceptor",
+        {
+          representedTaxId,
+          forceRefresh
+        },
+        {
+          ...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, forceRefresh }) {
+      const result = await executeWsfeAuthenticatedOperation(
+        "FEParamGetCotizacion",
+        {
+          representedTaxId,
+          forceRefresh
+        },
+        {
+          MonId: currencyId
+        }
+      );
+      const raw = result.ResultGet ?? {};
+      return mapWsfeQuotation(raw);
+    },
+    async getVoucherInfo(input) {
+      const lookup = await lookupVoucher(input);
+      return lookup.kind === "found" ? lookup.voucher : null;
+    },
+    lookupVoucher
+  };
+}
+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,
+    CondicionIVAReceptorId: input.receiverVatConditionId,
+    PtoVta: input.salesPoint,
+    CbteTipo: input.voucherType
+  };
+  if (input.exchangeRate !== void 0) {
+    data.MonCotiz = input.exchangeRate;
+  }
+  if (input.currencyId !== "PES" && 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) {
+  if (input.receiverVatConditionId === void 0) {
+    throw new ArcaInputError("receiverVatConditionId is required.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "receiverVatConditionId",
+      expected: "a receiver VAT condition accepted for the voucher class"
+    });
+  }
+  const {
+    voucherDate,
+    exchangeRate,
+    serviceStartDate,
+    serviceEndDate,
+    paymentDueDate,
+    associatedVouchers,
+    associatedPeriod,
+    taxes,
+    vatRates,
+    ...rest
+  } = input;
+  const normalizedExchangeRate = normalizeWsfeExchangeRate(input, exchangeRate);
+  const normalizedAmounts = normalizeAndValidateWsfeAmounts(input);
+  return {
+    ...rest,
+    ...normalizedAmounts,
+    voucherDate: normalizeWsfeDateInput(voucherDate, "voucherDate"),
+    ...normalizedExchangeRate === void 0 ? {} : { exchangeRate: normalizedExchangeRate },
+    ...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"
+        )
+      }
+    },
+    ...taxes === void 0 ? {} : {
+      taxes: taxes.map((tax, index) => ({
+        ...tax,
+        baseAmount: serializeArcaAmount(
+          tax.baseAmount,
+          `taxes[${index}].baseAmount`
+        ),
+        rate: serializeArcaPercentage(tax.rate, `taxes[${index}].rate`),
+        amount: serializeArcaAmount(tax.amount, `taxes[${index}].amount`)
+      }))
+    },
+    ...vatRates === void 0 ? {} : {
+      vatRates: vatRates.map((vatRate, index) => ({
+        ...vatRate,
+        baseAmount: serializeArcaAmount(
+          vatRate.baseAmount,
+          `vatRates[${index}].baseAmount`
+        ),
+        amount: serializeArcaAmount(
+          vatRate.amount,
+          `vatRates[${index}].amount`
+        )
+      }))
+    }
+  };
+}
+function normalizeAndValidateWsfeAmounts(input) {
+  const totalAmount = normalizeArcaAmountToMinorUnits(
+    input.totalAmount,
+    "totalAmount"
+  );
+  const nonTaxableAmount = normalizeArcaAmountToMinorUnits(
+    input.nonTaxableAmount,
+    "nonTaxableAmount"
+  );
+  const netAmount = normalizeArcaAmountToMinorUnits(
+    input.netAmount,
+    "netAmount"
+  );
+  const exemptAmount = normalizeArcaAmountToMinorUnits(
+    input.exemptAmount,
+    "exemptAmount"
+  );
+  const taxAmount = normalizeArcaAmountToMinorUnits(
+    input.taxAmount,
+    "taxAmount"
+  );
+  const vatAmount = normalizeArcaAmountToMinorUnits(
+    input.vatAmount,
+    "vatAmount"
+  );
+  const decomposedTotal = nonTaxableAmount + netAmount + exemptAmount + taxAmount + vatAmount;
+  assertWsfeAmountMatch(
+    totalAmount,
+    decomposedTotal,
+    "totalAmount",
+    "the sum of nonTaxableAmount, netAmount, exemptAmount, taxAmount, and vatAmount"
+  );
+  const vatRates = input.vatRates ?? [];
+  if (vatAmount > 0n && vatRates.length === 0) {
+    throw new ArcaInputError(
+      "vatRates is required when vatAmount is greater than zero.",
+      {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "vatRates",
+        expected: "VAT detail whose amounts reconcile with vatAmount"
+      }
+    );
+  }
+  if (vatRates.length > 0) {
+    const normalizedVatRates = vatRates.map((vatRate, index) => ({
+      baseAmount: normalizeArcaAmountToMinorUnits(
+        vatRate.baseAmount,
+        `vatRates[${index}].baseAmount`
+      ),
+      amount: normalizeArcaAmountToMinorUnits(
+        vatRate.amount,
+        `vatRates[${index}].amount`
+      )
+    }));
+    const vatRateAmountSum = normalizedVatRates.reduce(
+      (sum, vatRate) => sum + vatRate.amount,
+      0n
+    );
+    const vatRateBaseSum = normalizedVatRates.reduce(
+      (sum, vatRate) => sum + vatRate.baseAmount,
+      0n
+    );
+    assertWsfeAmountMatch(
+      vatAmount,
+      vatRateAmountSum,
+      "vatAmount",
+      "the sum of vatRates[].amount",
+      vatRates.length
+    );
+    if (requiresWsfeVatBaseReconciliation(input.voucherType)) {
+      assertWsfeAmountMatch(
+        netAmount,
+        vatRateBaseSum,
+        "netAmount",
+        "the sum of vatRates[].baseAmount",
+        vatRates.length
+      );
+    }
+  }
+  const taxes = input.taxes ?? [];
+  if (taxAmount > 0n && taxes.length === 0) {
+    throw new ArcaInputError(
+      "taxes is required when taxAmount is greater than zero.",
+      {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "taxes",
+        expected: "tax detail whose amounts reconcile with taxAmount"
+      }
+    );
+  }
+  if (taxes.length > 0) {
+    const taxAmountSum = taxes.reduce((sum, tax, index) => {
+      normalizeArcaAmountToMinorUnits(
+        tax.baseAmount,
+        `taxes[${index}].baseAmount`
+      );
+      serializeArcaPercentage(tax.rate, `taxes[${index}].rate`);
+      return sum + normalizeArcaAmountToMinorUnits(tax.amount, `taxes[${index}].amount`);
+    }, 0n);
+    assertWsfeAmountMatch(
+      taxAmount,
+      taxAmountSum,
+      "taxAmount",
+      "the sum of taxes[].amount",
+      taxes.length
+    );
+  }
+  return {
+    totalAmount: serializeArcaAmount(input.totalAmount, "totalAmount"),
+    nonTaxableAmount: serializeArcaAmount(
+      input.nonTaxableAmount,
+      "nonTaxableAmount"
+    ),
+    netAmount: serializeArcaAmount(input.netAmount, "netAmount"),
+    exemptAmount: serializeArcaAmount(input.exemptAmount, "exemptAmount"),
+    taxAmount: serializeArcaAmount(input.taxAmount, "taxAmount"),
+    vatAmount: serializeArcaAmount(input.vatAmount, "vatAmount")
+  };
+}
+function requiresWsfeVatBaseReconciliation(voucherType) {
+  return ![2, 3, 7, 8, 11, 12, 13, 15, 52, 53].includes(voucherType);
+}
+function assertWsfeAmountMatch(actual, expectedAmount, field, expectedDescription, absoluteCentAllowance = 1) {
+  if (!isWithinArcaTolerance(actual, expectedAmount, absoluteCentAllowance)) {
+    throw new ArcaInputError(
+      `${field} does not reconcile within ARCA's documented tolerance.`,
+      {
+        code: "ARCA_INPUT_AMOUNT_MISMATCH",
+        field,
+        expected: `within ARCA tolerance of ${expectedDescription}`
+      }
+    );
+  }
+}
+function normalizeWsfeExchangeRate(input, exchangeRate) {
+  if (input.currencyId === "PES") {
+    if (exchangeRate !== void 0 && serializeArcaExchangeRate(exchangeRate, "exchangeRate") !== "1") {
+      throw new ArcaInputError(
+        "exchangeRate must be 1 when currencyId is PES.",
+        {
+          code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
+          field: "exchangeRate",
+          expected: "1 when currencyId is PES"
+        }
+      );
+    }
+    return "1";
+  }
+  if (exchangeRate === void 0) {
+    if (input.sameCurrencyForeignCancellation === "S") {
+      return void 0;
+    }
+    throw new ArcaInputError(
+      "exchangeRate is required unless sameCurrencyForeignCancellation is S for a foreign-currency voucher.",
+      {
+        code: "ARCA_INPUT_MISSING_FIELD",
+        field: "exchangeRate",
+        expected: "a positive exchange rate unless sameCurrencyForeignCancellation is S"
+      }
+    );
+  }
+  return serializeArcaExchangeRate(exchangeRate, "exchangeRate");
+}
+function normalizeWsfeDateInput(value, fieldName) {
+  if (typeof value !== "string") {
+    throw new ArcaInputError(
+      `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+      {
+        code: "ARCA_INPUT_INVALID_DATE",
+        field: fieldName,
+        expected: "a YYYY-MM-DD or YYYYMMDD calendar date string"
+      }
+    );
+  }
+  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);
+    return normalizedValue;
+  }
+  const isoMatch = normalizedValue.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (isoMatch) {
+    const [, year, month, day] = isoMatch;
+    assertValidCalendarDate(year, month, day, fieldName);
+    return `${year}${month}${day}`;
+  }
+  throw new ArcaInputError(
+    `Invalid WSFE ${fieldName}: expected a YYYY-MM-DD or YYYYMMDD string`,
+    {
+      code: "ARCA_INPUT_INVALID_DATE",
+      field: fieldName,
+      expected: "a YYYY-MM-DD or YYYYMMDD calendar date string"
+    }
+  );
+}
+function assertValidCalendarDate(yearInput, monthInput, dayInput, fieldName) {
+  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`,
+      {
+        code: "ARCA_INPUT_INVALID_DATE",
+        field: fieldName,
+        expected: "an existing calendar date"
+      }
+    );
+  }
+}
+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) {
+  const voucher = {
+    voucherNumber: Number(raw.CbteDesde ?? raw.CbteHasta ?? 0),
+    raw
+  };
+  assignWsfeValue(voucher, "voucherDate", normalizeWsfeString(raw.CbteFch));
+  assignWsfeValue(voucher, "salesPoint", normalizeWsfeNumber(raw.PtoVta));
+  assignWsfeValue(voucher, "voucherType", normalizeWsfeNumber(raw.CbteTipo));
+  assignWsfeValue(voucher, "concept", normalizeWsfeNumber(raw.Concepto));
+  assignWsfeValue(voucher, "documentType", normalizeWsfeNumber(raw.DocTipo));
+  assignWsfeValue(voucher, "documentNumber", normalizeWsfeString(raw.DocNro));
+  assignWsfeValue(
+    voucher,
+    "receiverVatConditionId",
+    normalizeWsfeNumber(raw.CondicionIVAReceptorId)
+  );
+  assignWsfeValue(voucher, "totalAmount", normalizeWsfeNumber(raw.ImpTotal));
+  assignWsfeValue(
+    voucher,
+    "nonTaxableAmount",
+    normalizeWsfeNumber(raw.ImpTotConc)
+  );
+  assignWsfeValue(voucher, "netAmount", normalizeWsfeNumber(raw.ImpNeto));
+  assignWsfeValue(voucher, "exemptAmount", normalizeWsfeNumber(raw.ImpOpEx));
+  assignWsfeValue(voucher, "taxAmount", normalizeWsfeNumber(raw.ImpTrib));
+  assignWsfeValue(voucher, "vatAmount", normalizeWsfeNumber(raw.ImpIVA));
+  assignWsfeValue(voucher, "currencyId", normalizeWsfeString(raw.MonId));
+  assignWsfeValue(voucher, "exchangeRate", normalizeWsfeNumber(raw.MonCotiz));
+  assignWsfeValue(voucher, "result", normalizeWsfeString(raw.Resultado));
+  assignWsfeValue(
+    voucher,
+    "cae",
+    normalizeWsfeString(raw.CodAutorizacion ?? raw.CAE)
+  );
+  assignWsfeValue(
+    voucher,
+    "caeExpiry",
+    normalizeWsfeString(raw.FchVto ?? raw.CAEFchVto)
+  );
+  return voucher;
+}
+function createWsfeAuth(representedTaxId, token, sign) {
+  return {
+    Token: token,
+    Sign: sign,
+    Cuit: Number.parseInt(String(representedTaxId), 10)
+  };
+}
+function unwrapWsfeOperationEnvelope(operation, response) {
+  const operationResponse = response[`${operation}Response`];
+  const result = operationResponse?.[`${operation}Result`] ?? response[`${operation}Result`] ?? response;
+  return result;
+}
+function throwForWsfeOperationErrors(operation, result) {
+  const errors = extractWsfeGlobalIssues(result, operation);
+  if (errors.length > 0) {
+    throw createWsfeServiceError(operation, errors);
+  }
+}
+function normalizeWsfeDetailResponse(result) {
+  const detailResponse = result.FeDetResp;
+  const rawDetail = detailResponse?.FECAEDetResponse;
+  if (Array.isArray(rawDetail)) {
+    return rawDetail[0] ?? {};
+  }
+  return rawDetail ?? {};
+}
+function classifyWsfeAuthorization(result, voucherNumber) {
+  const operation = "FECAESolicitar";
+  const header = toWsfeRecord(result.FeCabResp) ?? {};
+  const detail = normalizeWsfeDetailResponse(result);
+  const headerResult = normalizeWsfeResult(header.Resultado);
+  const detailResult = normalizeWsfeResult(detail.Resultado);
+  const resultCode = detailResult ?? headerResult;
+  const resultLevel = getWsfeResultLevel(headerResult, detailResult);
+  const cae = normalizeWsfeString(detail.CAE);
+  const caeExpiry = normalizeWsfeString(detail.CAEFchVto);
+  const errors = extractWsfeGlobalIssues(result, operation, "header");
+  const observations = extractWsfeObservations(
+    detail,
+    detailResult === "R" ? "business" : "observation"
+  );
+  const hasInfrastructureError = errors.some(
+    (issue) => issue.category === "infrastructure"
+  );
+  const base = {
+    service: "wsfe",
+    operation,
+    results: createWsfeResults(headerResult, detailResult),
+    errors,
+    observations,
+    raw: result
+  };
+  const context = {
+    base,
+    headerResult,
+    detailResult,
+    resultCode,
+    resultLevel,
+    cae,
+    caeExpiry
+  };
+  if (hasContradictoryWsfeResults(context)) {
+    return createWsfeStructuredIndeterminate(context, "contradictory_response");
+  }
+  const authenticationError = classifyArcaAuthenticationIssues(errors, {
+    service: "wsfe",
+    operation
+  });
+  if (authenticationError && detailResult === void 0 && headerResult !== "A" && headerResult !== "O" && !cae) {
+    return {
+      ...createWsfeStructuredIndeterminate(context, "authentication_rejected"),
+      authentication: createArcaAuthenticationEvidence(authenticationError)
+    };
+  }
+  if (hasInfrastructureError) {
+    return createWsfeStructuredIndeterminate(context, "incomplete_response");
+  }
+  if (isAuthorizedWsfeContext(context)) {
+    return {
+      ...base,
+      kind: "authorized",
+      result: "A",
+      resultLevel: "detail",
+      cae: context.cae,
+      caeExpiry: context.caeExpiry,
+      voucherNumber
+    };
+  }
+  if (isRejectedWsfeDetailContext(context)) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "detail"
+    };
+  }
+  if (isRejectedWsfeHeaderContext(context)) {
+    return {
+      ...base,
+      kind: "rejected",
+      result: "R",
+      resultLevel: "header"
+    };
+  }
+  return createWsfeStructuredIndeterminate(
+    context,
+    hasWsfeCaeContradiction(context) ? "contradictory_response" : "incomplete_response"
+  );
+}
+function getWsfeResultLevel(headerResult, detailResult) {
+  if (detailResult) {
+    return "detail";
+  }
+  return headerResult ? "header" : void 0;
+}
+function hasContradictoryWsfeResults(context) {
+  return Boolean(
+    context.headerResult && context.detailResult && context.headerResult !== context.detailResult
+  );
+}
+function isAuthorizedWsfeContext(context) {
+  return Boolean(
+    context.detailResult === "A" && context.headerResult !== "R" && context.base.errors.length === 0 && context.cae && context.caeExpiry
+  );
+}
+function isRejectedWsfeDetailContext(context) {
+  return context.detailResult === "R" && context.headerResult !== "A" && !context.cae;
+}
+function isRejectedWsfeHeaderContext(context) {
+  return context.headerResult === "R" && context.detailResult === void 0 && !context.cae && context.base.errors.length > 0 && context.base.errors.every((issue) => issue.category === "business");
+}
+function hasWsfeCaeContradiction(context) {
+  return (context.resultCode === "A" || context.resultCode === "R") && Boolean(context.cae);
+}
+function createWsfeStructuredIndeterminate(context, reason) {
+  const outcome = {
+    ...context.base,
+    kind: "indeterminate",
+    reason
+  };
+  assignWsfeValue(outcome, "result", context.resultCode);
+  assignWsfeValue(outcome, "resultLevel", context.resultLevel);
+  assignWsfeValue(outcome, "cae", context.cae);
+  assignWsfeValue(outcome, "caeExpiry", context.caeExpiry);
+  return outcome;
+}
+function createWsfeResults(headerResult, detailResult) {
+  const results = {};
+  assignWsfeValue(results, "header", headerResult);
+  assignWsfeValue(results, "detail", detailResult);
+  return results;
+}
+function createWsfeIndeterminateOutcome(error) {
+  const authenticationError = classifyArcaAuthenticationError(error, {
+    service: "wsfe",
+    operation: "FECAESolicitar"
+  });
+  return {
+    kind: "indeterminate",
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    results: {},
+    reason: authenticationError ? "authentication_rejected" : getArcaIndeterminateReason(error),
+    ...authenticationError ? {
+      authentication: createArcaAuthenticationEvidence(authenticationError)
+    } : {},
+    errors: [],
+    observations: []
+  };
+}
+function getArcaIndeterminateReason(error) {
+  if (error instanceof ArcaTransportError) {
+    return "transport_error";
+  }
+  if (error instanceof ArcaSoapFaultError) {
+    return "soap_fault";
+  }
+  if (error instanceof ArcaInvalidSoapResponseError) {
+    return "invalid_response";
+  }
+  return "unexpected_error";
+}
+function createWsfeOutcomeError(outcome) {
+  if (outcome.kind === "indeterminate" && outcome.authentication) {
+    return createArcaAuthenticationErrorFromEvidence(outcome.authentication, {
+      service: "wsfe",
+      operation: outcome.operation
+    });
+  }
+  const issues = [...outcome.errors, ...outcome.observations];
+  const firstIssue = issues[0];
+  const message = firstIssue ? formatWsfeIssue(firstIssue) : outcome.kind === "rejected" ? "WSFE rejected the voucher authorization" : outcome.result === "A" ? "WSFE did not return CAE authorization data" : "WSFE did not return conclusive voucher authorization data";
+  return new ArcaServiceError(message, {
+    service: "wsfe",
+    operation: outcome.operation,
+    ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+    ...outcome.result === void 0 ? {} : { result: outcome.result },
+    ...outcome.resultLevel === void 0 ? {} : { resultLevel: outcome.resultLevel },
+    results: outcome.results,
+    ...outcome.kind === "indeterminate" && outcome.cae ? { cae: outcome.cae } : {},
+    issues
+  });
+}
+function createWsfeServiceError(operation, issues) {
+  const authenticationError = classifyArcaAuthenticationIssues(issues, {
+    service: "wsfe",
+    operation
+  });
+  if (authenticationError) {
+    return authenticationError;
+  }
+  const firstIssue = issues[0];
+  return new ArcaServiceError(
+    firstIssue ? formatWsfeIssue(firstIssue) : "WSFE returned a service error",
+    {
+      service: "wsfe",
+      operation,
+      ...firstIssue?.code === void 0 ? {} : { serviceCode: firstIssue.code },
+      issues
+    }
+  );
+}
+function extractWsfeGlobalIssues(result, operation, resultLevel) {
+  const errorsContainer = toWsfeRecord(result.Errors);
+  return normalizeWsfeIssueEntries(errorsContainer?.Err).map((entry) => ({
+    service: "wsfe",
+    operation,
+    source: "error",
+    category: operation === "FECAESolicitar" && WSFE_AUTHORIZATION_INFRASTRUCTURE_CODES.has(entry.code ?? "") ? "infrastructure" : operation === "FECAESolicitar" ? "business" : "unknown",
+    ...entry.code === void 0 ? {} : { code: entry.code },
+    message: entry.message,
+    ...resultLevel === void 0 ? {} : { resultLevel }
+  }));
+}
+function extractWsfeObservations(detail, category) {
+  const observationsContainer = toWsfeRecord(detail.Observaciones);
+  return normalizeWsfeIssueEntries(observationsContainer?.Obs).map((entry) => ({
+    service: "wsfe",
+    operation: "FECAESolicitar",
+    source: "observation",
+    category,
+    ...entry.code === void 0 ? {} : { code: entry.code },
+    message: entry.message,
+    resultLevel: "detail"
+  }));
+}
+function normalizeWsfeIssueEntries(rawErrors) {
+  const entries = Array.isArray(rawErrors) ? rawErrors : rawErrors ? [rawErrors] : [];
+  return entries.map((entry) => entry).map((entry) => {
+    const code = entry.Code ?? entry.code;
+    const message = entry.Msg ?? entry.msg ?? "Unknown WSFE error";
+    return {
+      ...code === void 0 ? {} : { code: String(code) },
+      message: String(message)
+    };
+  });
+}
+function formatWsfeIssue(issue) {
+  return issue.code ? `(${issue.code}) ${issue.message}` : issue.message;
+}
+function normalizeWsfeResult(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toUpperCase();
+  return normalized || void 0;
+}
+function normalizeWsfeString(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalized = String(value).trim();
+  return normalized || void 0;
+}
+function normalizeWsfeNumber(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const normalized = Number(value);
+  return Number.isFinite(normalized) ? normalized : void 0;
+}
+function assignWsfeValue(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function toWsfeRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+var WSFE_AUTHORIZATION_INFRASTRUCTURE_CODES = /* @__PURE__ */ new Set([
+  "500",
+  "501",
+  "502",
+  "600",
+  "601"
+]);
+function getWsfeResultEntries(result, key) {
+  const rawEntries = result.ResultGet?.[key];
+  if (!rawEntries) {
+    return [];
+  }
+  return (Array.isArray(rawEntries) ? rawEntries : [rawEntries]).map(
+    (entry) => entry
+  );
+}
+
+// src/services/wsfe-builders.ts
+var VAT_RATE_IDS = {
+  0: ARCA_VAT_RATES.IVA_0,
+  2.5: ARCA_VAT_RATES.IVA_2_5,
+  5: ARCA_VAT_RATES.IVA_5,
+  10.5: ARCA_VAT_RATES.IVA_10_5,
+  21: ARCA_VAT_RATES.IVA_21,
+  27: ARCA_VAT_RATES.IVA_27
+};
+function buildFacturaB(input) {
+  const taxableMinorUnits = assertArcaMinorUnits(
+    input.taxableAmount,
+    "taxableAmount"
+  );
+  if (taxableMinorUnits === 0n) {
+    throw new ArcaInputError(
+      "taxableAmount must be greater than zero for Factura B.",
+      {
+        code: "ARCA_INPUT_INVALID_AMOUNT",
+        field: "taxableAmount",
+        expected: "a positive safe integer in currency minor units"
+      }
+    );
+  }
+  const vatMinorUnits = calculateVatMinorUnits(
+    taxableMinorUnits,
+    input.vatRate,
+    "vatRate"
+  );
+  const totalMinorUnits = taxableMinorUnits + vatMinorUnits;
+  const vatRateId = VAT_RATE_IDS[input.vatRate];
+  if (vatRateId === void 0) {
+    throw new ArcaInputError("vatRate is not a supported VAT rate.", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "vatRate",
+      expected: "one of 0, 2.5, 5, 10.5, 21, or 27"
+    });
+  }
+  if (input.vatRate !== 0 && vatMinorUnits === 0n) {
+    throw new ArcaInputError(
+      "taxableAmount is too small to produce VAT at the selected positive vatRate.",
+      {
+        code: "ARCA_INPUT_INVALID_AMOUNT",
+        field: "taxableAmount",
+        expected: "an amount that rounds to at least one currency minor unit of VAT for a positive vatRate"
+      }
+    );
+  }
+  const vatRates = [
+    Object.freeze({
+      id: vatRateId,
+      baseAmount: arcaMinorUnitsToNumber(taxableMinorUnits, "taxableAmount"),
+      amount: arcaMinorUnitsToNumber(vatMinorUnits, "vatAmount")
+    })
+  ];
+  Object.freeze(vatRates);
+  return Object.freeze({
+    ...buildCommonExactInput(input),
+    voucherType: ARCA_VOUCHER_TYPES.FACTURA_B,
+    totalAmount: arcaMinorUnitsToNumber(totalMinorUnits, "totalAmount"),
+    nonTaxableAmount: 0,
+    netAmount: arcaMinorUnitsToNumber(taxableMinorUnits, "taxableAmount"),
+    exemptAmount: 0,
+    taxAmount: 0,
+    vatAmount: arcaMinorUnitsToNumber(vatMinorUnits, "vatAmount"),
+    vatRates
+  });
+}
+function buildFacturaC(input) {
+  const amountMinorUnits = assertArcaMinorUnits(input.amount, "amount");
+  const amount = arcaMinorUnitsToNumber(amountMinorUnits, "amount");
+  return Object.freeze({
+    ...buildCommonExactInput(input),
+    voucherType: ARCA_VOUCHER_TYPES.FACTURA_C,
+    totalAmount: amount,
+    nonTaxableAmount: 0,
+    // ARCA defines ImpNeto as the subtotal for class C vouchers.
+    netAmount: amount,
+    exemptAmount: 0,
+    taxAmount: 0,
+    vatAmount: 0
+  });
+}
+function buildCommonExactInput(input) {
+  return {
+    salesPoint: input.salesPoint,
+    concept: input.concept,
+    documentType: input.documentType,
+    documentNumber: input.documentNumber,
+    receiverVatConditionId: input.receiverVatConditionId,
+    voucherDate: input.voucherDate,
+    ...normalizeBuilderCurrency(input),
+    ...input.serviceStartDate === void 0 ? {} : { serviceStartDate: input.serviceStartDate },
+    ...input.serviceEndDate === void 0 ? {} : { serviceEndDate: input.serviceEndDate },
+    ...input.paymentDueDate === void 0 ? {} : { paymentDueDate: input.paymentDueDate }
+  };
+}
+function normalizeBuilderCurrency(input) {
+  const unsafeInput = input;
+  const currency = unsafeInput.currency ?? "ARS";
+  if (unsafeInput.sameCurrencyForeignCancellation !== void 0 && typeof unsafeInput.sameCurrencyForeignCancellation !== "boolean") {
+    throw new ArcaInputError(
+      "sameCurrencyForeignCancellation must be a boolean when provided.",
+      {
+        code: "ARCA_INPUT_INVALID_VALUE",
+        field: "sameCurrencyForeignCancellation",
+        expected: "true, false, or omitted"
+      }
+    );
+  }
+  if (currency === "ARS") {
+    if (unsafeInput.exchangeRate !== void 0) {
+      throw new ArcaInputError(
+        "exchangeRate must be omitted when currency is ARS.",
+        {
+          code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
+          field: "exchangeRate",
+          expected: "omitted when currency is ARS"
+        }
+      );
+    }
+    if (unsafeInput.sameCurrencyForeignCancellation !== void 0) {
+      throw new ArcaInputError(
+        "sameCurrencyForeignCancellation applies only when currency is USD.",
+        {
+          code: "ARCA_INPUT_INVALID_VALUE",
+          field: "sameCurrencyForeignCancellation",
+          expected: "omitted when currency is ARS"
+        }
+      );
+    }
+    return {
+      currencyId: ARCA_CURRENCY_IDS.ARS,
+      exchangeRate: "1"
+    };
+  }
+  if (currency !== "USD") {
+    throw new ArcaInputError("currency is not supported by this builder.", {
+      code: "ARCA_INPUT_INVALID_VALUE",
+      field: "currency",
+      expected: "ARS or USD"
+    });
+  }
+  if (unsafeInput.sameCurrencyForeignCancellation === true) {
+    if (unsafeInput.exchangeRate !== void 0) {
+      throw new ArcaInputError(
+        "exchangeRate must be omitted for same-currency foreign cancellation.",
+        {
+          code: "ARCA_INPUT_INVALID_EXCHANGE_RATE",
+          field: "exchangeRate",
+          expected: "omitted when sameCurrencyForeignCancellation is true"
+        }
+      );
+    }
+    return {
+      currencyId: ARCA_CURRENCY_IDS.USD,
+      sameCurrencyForeignCancellation: "S"
+    };
+  }
+  if (typeof unsafeInput.exchangeRate !== "string") {
+    throw new ArcaInputError("exchangeRate is required for USD invoices.", {
+      code: "ARCA_INPUT_MISSING_FIELD",
+      field: "exchangeRate",
+      expected: "a decimal string unless sameCurrencyForeignCancellation is true"
+    });
+  }
+  return {
+    currencyId: ARCA_CURRENCY_IDS.USD,
+    exchangeRate: serializeArcaExchangeRate(
+      unsafeInput.exchangeRate,
+      "exchangeRate"
+    ),
+    ...unsafeInput.sameCurrencyForeignCancellation === false ? { sameCurrencyForeignCancellation: "N" } : {}
+  };
+}
+
+export {
+  createWsfeService,
+  buildFacturaB,
+  buildFacturaC
+};
+//# sourceMappingURL=chunk-OHHXHYLV.mjs.map