@pagosrd/azul 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,817 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AZUL_URLS: () => AZUL_URLS,
+  AzulAmbiguousError: () => AzulAmbiguousError,
+  AzulClient: () => AzulClient,
+  AzulConfigError: () => AzulConfigError,
+  AzulError: () => AzulError,
+  AzulHttpError: () => AzulHttpError,
+  AzulResponseError: () => AzulResponseError,
+  AzulValidationError: () => AzulValidationError,
+  PAYMENT_PAGE_HASH_FIELDS: () => PAYMENT_PAGE_HASH_FIELDS,
+  PAYMENT_PAGE_RESPONSE_HASH_FIELDS: () => PAYMENT_PAGE_RESPONSE_HASH_FIELDS,
+  defaultPaymentPageHash: () => defaultPaymentPageHash,
+  escapeHtml: () => escapeHtml,
+  maskPan: () => maskPan,
+  passesLuhn: () => passesLuhn,
+  paymentPageResponseHash: () => paymentPageResponseHash,
+  redact: () => redact,
+  toCents: () => toCents,
+  verifyPaymentPageResponse: () => verifyPaymentPageResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_node_crypto2 = require("crypto");
+
+// src/config.ts
+var import_zod = require("zod");
+
+// src/errors.ts
+var AzulError = class extends Error {
+  name = "AzulError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var AzulConfigError = class extends AzulError {
+  name = "AzulConfigError";
+};
+var AzulValidationError = class extends AzulError {
+  name = "AzulValidationError";
+  issues;
+  constructor(message, issues = []) {
+    super(message);
+    this.issues = issues;
+  }
+};
+var AzulResponseError = class extends AzulError {
+  name = "AzulResponseError";
+  response;
+  constructor(message, response) {
+    super(message);
+    this.response = response;
+  }
+};
+var AzulHttpError = class extends AzulError {
+  name = "AzulHttpError";
+  statusCode;
+  body;
+  constructor(message, statusCode, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+  }
+};
+var AzulAmbiguousError = class extends AzulError {
+  name = "AzulAmbiguousError";
+  customOrderId;
+  constructor(message, customOrderId, options) {
+    super(message, options);
+    this.customOrderId = customOrderId;
+  }
+};
+
+// src/config.ts
+var AZUL_URLS = {
+  pruebas: {
+    webservices: "https://pruebas.azul.com.do/webservices/JSON/Default.aspx",
+    paymentPage: "https://pruebas.azul.com.do/PaymentPage/"
+  },
+  produccion: {
+    webservices: "https://pagos.azul.com.do/webservices/JSON/Default.aspx",
+    webservicesAlterna: "https://contpagos.azul.com.do/Webservices/JSON/default.aspx",
+    paymentPage: "https://pagos.azul.com.do/PaymentPage/Default.aspx"
+  }
+};
+var nonEmpty = (field) => import_zod.z.string({ error: `${field} es requerido` }).trim().min(1, `${field} no puede estar vac\xEDo`);
+var pem = (field) => import_zod.z.union([import_zod.z.string(), import_zod.z.instanceof(Buffer)]).refine((v) => String(v).includes("-----BEGIN"), {
+  message: `${field} debe ser el contenido PEM (empieza con "-----BEGIN"), no una ruta de archivo`
+});
+var configSchema = import_zod.z.object({
+  merchantId: nonEmpty("merchantId").max(11, "merchantId tiene un m\xE1ximo de 11 caracteres"),
+  auth1: nonEmpty("auth1"),
+  auth2: nonEmpty("auth2"),
+  environment: import_zod.z.enum(["pruebas", "produccion"], { error: 'environment debe ser "pruebas" o "produccion"' }),
+  channel: import_zod.z.string().max(3).optional(),
+  timeoutMs: import_zod.z.number().int().positive().max(12e4).optional(),
+  paymentPage: import_zod.z.object({ authKey: nonEmpty("paymentPage.authKey"), merchantName: nonEmpty("paymentPage.merchantName"), merchantType: nonEmpty("paymentPage.merchantType") }).optional()
+});
+function resolveConfig(input) {
+  const parsed = configSchema.safeParse(input);
+  const issues = parsed.success ? [] : parsed.error.issues.map((i) => i.message);
+  if (!input.dispatcher) {
+    for (const [field, value] of [["certificate", input.certificate], ["privateKey", input.privateKey]]) {
+      const check = pem(field).safeParse(value);
+      if (!check.success) issues.push(...check.error.issues.map((i) => i.message));
+    }
+  }
+  if (issues.length > 0) {
+    throw new AzulConfigError(`Configuraci\xF3n de AZUL inv\xE1lida: ${issues.join("; ")}`);
+  }
+  const env = input.environment;
+  const urls = AZUL_URLS[env];
+  return {
+    ...input,
+    channel: input.channel ?? "EC",
+    timeoutMs: input.timeoutMs ?? 3e4,
+    webservicesUrl: input.urls?.webservices ?? urls.webservices,
+    webservicesAlternaUrl: input.urls?.webservicesAlterna ?? (env === "produccion" ? AZUL_URLS.produccion.webservicesAlterna : void 0),
+    paymentPageUrl: urls.paymentPage
+  };
+}
+
+// src/money.ts
+var MAX_CENTS = 999999999999;
+function centsToAzul(value, field, options = {}) {
+  if (!Number.isSafeInteger(value)) {
+    throw new AzulValidationError(
+      `${field} debe ser un entero de centavos (por ejemplo 150050 para RD$1,500.50). Recibido: ${String(value)}`,
+      [field]
+    );
+  }
+  if (value < 0) {
+    throw new AzulValidationError(`${field} no puede ser negativo.`, [field]);
+  }
+  if (value === 0 && !options.allowZero) {
+    throw new AzulValidationError(`${field} debe ser mayor que cero.`, [field]);
+  }
+  if (value > MAX_CENTS) {
+    throw new AzulValidationError(`${field} excede el m\xE1ximo de 12 d\xEDgitos que acepta AZUL.`, [field]);
+  }
+  return String(value);
+}
+function itbisToAzul(value) {
+  if (value === void 0 || value === 0) return "000";
+  return centsToAzul(value, "itbis");
+}
+function toCents(amount) {
+  const text = typeof amount === "number" ? amount.toString() : amount;
+  const noSymbol = text.trim().replace(/^RD\$\s*/i, "");
+  if (noSymbol.includes(",") && !/^\d{1,3}(,\d{3})+(\.\d{1,2})?$/.test(noSymbol)) {
+    throw new AzulValidationError(`Monto ambiguo: "${text}". Usa punto para los decimales y coma solo para los miles.`, ["amount"]);
+  }
+  const cleaned = noSymbol.replace(/,/g, "");
+  const match = /^(\d+)(?:\.(\d{1,2}))?$/.exec(cleaned);
+  if (!match) {
+    throw new AzulValidationError(
+      `Monto inv\xE1lido: "${text}". Usa como m\xE1ximo 2 decimales, por ejemplo "1,500.50".`,
+      ["amount"]
+    );
+  }
+  const pesos = match[1] ?? "0";
+  const decimals = (match[2] ?? "").padEnd(2, "0");
+  const cents = Number(pesos) * 100 + Number(decimals);
+  if (!Number.isSafeInteger(cents)) {
+    throw new AzulValidationError(`Monto demasiado grande: "${text}".`, ["amount"]);
+  }
+  return cents;
+}
+
+// src/payment-page.ts
+var import_node_crypto = require("crypto");
+
+// src/validation.ts
+function passesLuhn(digits) {
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function cardNumber(value) {
+  const digits = String(value).replace(/[\s-]/g, "");
+  if (!/^\d{12,19}$/.test(digits)) {
+    throw new AzulValidationError("cardNumber debe tener entre 12 y 19 d\xEDgitos.", ["cardNumber"]);
+  }
+  if (!passesLuhn(digits)) {
+    throw new AzulValidationError("cardNumber no es un n\xFAmero de tarjeta v\xE1lido (falla la verificaci\xF3n de Luhn).", ["cardNumber"]);
+  }
+  return digits;
+}
+function expiration(value) {
+  const v = String(value).trim();
+  let year;
+  let month;
+  let m;
+  if (m = /^(\d{4})(\d{2})$/.exec(v)) {
+    year = Number(m[1]);
+    month = Number(m[2]);
+  } else if (m = /^(\d{1,2})\s*\/\s*(\d{2}|\d{4})$/.exec(v)) {
+    month = Number(m[1]);
+    year = Number(m[2].length === 2 ? `20${m[2]}` : m[2]);
+  } else {
+    throw new AzulValidationError('expiration debe tener el formato "YYYYMM", "MM/YY" o "MM/YYYY".', ["expiration"]);
+  }
+  if (month < 1 || month > 12) {
+    throw new AzulValidationError("expiration tiene un mes inv\xE1lido.", ["expiration"]);
+  }
+  return `${year}${String(month).padStart(2, "0")}`;
+}
+function cvc(value) {
+  const v = String(value).trim();
+  if (!/^\d{3,4}$/.test(v)) {
+    throw new AzulValidationError("cvc debe tener 3 o 4 d\xEDgitos.", ["cvc"]);
+  }
+  return v;
+}
+function maxText(value, field, max, options = {}) {
+  if (value === void 0 || value === "") {
+    if (options.required) throw new AzulValidationError(`${field} es requerido.`, [field]);
+    return void 0;
+  }
+  if (value.length > max) {
+    throw new AzulValidationError(`${field} admite como m\xE1ximo ${max} caracteres (tiene ${value.length}).`, [field]);
+  }
+  return value;
+}
+function azulOrderId(value) {
+  const v = String(value ?? "").trim();
+  if (!/^\d+$/.test(v)) {
+    throw new AzulValidationError("azulOrderId debe ser el identificador num\xE9rico que devolvi\xF3 AZUL.", ["azulOrderId"]);
+  }
+  return v;
+}
+function dataVaultToken(value) {
+  const v = String(value ?? "").trim();
+  if (!/^[A-Fa-f0-9-]{30,40}$/.test(v)) {
+    throw new AzulValidationError("dataVaultToken no tiene el formato de un token de DataVault.", ["dataVaultToken"]);
+  }
+  return v;
+}
+function httpsUrl(value, field) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new AzulValidationError(`${field} debe ser una URL v\xE1lida.`, [field]);
+  }
+  if (url.protocol !== "https:") {
+    throw new AzulValidationError(`${field} debe usar https://.`, [field]);
+  }
+  return value;
+}
+
+// src/payment-page.ts
+var PAYMENT_PAGE_HASH_FIELDS = [
+  "MerchantId",
+  "MerchantName",
+  "MerchantType",
+  "CurrencyCode",
+  "OrderNumber",
+  "Amount",
+  "ITBIS",
+  "ApprovedUrl",
+  "DeclinedUrl",
+  "CancelUrl",
+  "UseCustomField1",
+  "CustomField1Label",
+  "CustomField1Value",
+  "UseCustomField2",
+  "CustomField2Label",
+  "CustomField2Value"
+];
+var PAYMENT_PAGE_RESPONSE_HASH_FIELDS = [
+  "OrderNumber",
+  "Amount",
+  "AuthorizationCode",
+  "DateTime",
+  "ResponseCode",
+  "IsoCode",
+  "ResponseMessage",
+  "ErrorDescription",
+  "RRN"
+];
+function defaultPaymentPageHash(fields, authKey) {
+  const text = PAYMENT_PAGE_HASH_FIELDS.map((k) => fields[k] ?? "").join("") + authKey;
+  return (0, import_node_crypto.createHmac)("sha512", authKey).update(text, "utf8").digest("hex");
+}
+function paymentPageResponseHash(params, authKey) {
+  const text = PAYMENT_PAGE_RESPONSE_HASH_FIELDS.map((k) => params[k] ?? "").join("") + authKey;
+  return (0, import_node_crypto.createHmac)("sha512", authKey).update(Buffer.from(text, "utf16le")).digest("hex");
+}
+function verifyPaymentPageResponse(params, authKey) {
+  const received = (params.AuthHash ?? "").trim().toLowerCase();
+  if (!/^[0-9a-f]{128}$/.test(received)) return false;
+  const expected = paymentPageResponseHash(params, authKey);
+  return (0, import_node_crypto.timingSafeEqual)(Buffer.from(received, "hex"), Buffer.from(expected, "hex"));
+}
+function buildPaymentPage(input, merchant) {
+  const amount = centsToAzul(input.amount, "amount");
+  const itbis = input.itbis ? centsToAzul(input.itbis, "itbis", { allowZero: true }) : "000";
+  if (input.itbis !== void 0 && input.itbis > input.amount) {
+    throw new AzulValidationError("itbis no puede ser mayor que amount.", ["itbis"]);
+  }
+  const orderNumber = maxText(input.orderNumber, "orderNumber", 15, { required: true });
+  const alt = maxText(input.altMerchantName, "altMerchantName", 25);
+  if (alt && !/^[a-zA-Z0-9\s.,]*$/.test(alt)) {
+    throw new AzulValidationError("altMerchantName solo admite letras sin acento, n\xFAmeros, espacios, punto y coma.", ["altMerchantName"]);
+  }
+  const [cf1, cf2] = input.customFields ?? [];
+  const fields = {
+    TrxType: "Sale",
+    MerchantId: merchant.merchantId,
+    MerchantName: merchant.merchantName,
+    MerchantType: merchant.merchantType,
+    CurrencyCode: "$",
+    OrderNumber: orderNumber,
+    Amount: amount,
+    ITBIS: itbis,
+    ApprovedUrl: httpsUrl(input.approvedUrl, "approvedUrl"),
+    DeclinedUrl: httpsUrl(input.declineUrl, "declineUrl"),
+    CancelUrl: httpsUrl(input.cancelUrl, "cancelUrl"),
+    UseCustomField1: cf1 ? "1" : "0",
+    CustomField1Label: cf1?.label ?? "",
+    CustomField1Value: cf1?.value ?? "",
+    UseCustomField2: cf2 ? "1" : "0",
+    CustomField2Label: cf2?.label ?? "",
+    CustomField2Value: cf2?.value ?? "",
+    ShowTransactionResult: input.showTransactionResult === false ? "0" : "1",
+    Locale: input.locale ?? "ES"
+  };
+  if (alt) fields.AltMerchantName = alt;
+  if (input.saveToDataVault) fields.SaveToDataVault = "1";
+  fields.AuthHash = (merchant.hashFn ?? defaultPaymentPageHash)(fields, merchant.authKey);
+  return { url: merchant.url, fields, html: renderAutoSubmitForm(merchant.url, fields) };
+}
+var HTML_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => HTML_ESCAPES[c]);
+}
+function renderAutoSubmitForm(url, fields) {
+  const inputs = Object.entries(fields).map(([name, value]) => `    <input type="hidden" name="${escapeHtml(name)}" value="${escapeHtml(value)}">`).join("\n");
+  return `<!doctype html>
+<html lang="es">
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Redirigiendo al pago seguro</title></head>
+<body>
+  <form id="azul-payment" method="post" action="${escapeHtml(url)}">
+${inputs}
+    <noscript><button type="submit">Continuar al pago</button></noscript>
+  </form>
+  <script>document.getElementById("azul-payment").submit();</script>
+</body>
+</html>`;
+}
+
+// src/response.ts
+var SYSTEM_GATEWAY_ERRORS = [
+  "timeout",
+  "not been processed",
+  "Internal Server Error",
+  "Unauthorized",
+  "Server Unavailable",
+  "SSL/TLS",
+  "connection"
+];
+var str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+function interpretResponse(data, customOrderId) {
+  const responseCode = str(data.ResponseCode);
+  const isoCode = str(data.IsoCode);
+  const message = str(data.ResponseMessage);
+  const errorDescription = str(data.ErrorDescription);
+  const build = (status) => ({
+    status,
+    responseCode,
+    isoCode,
+    message,
+    errorDescription,
+    authorizationCode: str(data.AuthorizationCode),
+    azulOrderId: str(data.AzulOrderId),
+    rrn: str(data.RRN),
+    dataVaultToken: str(data.DataVaultToken),
+    customOrderId: str(data.CustomOrderId) ?? customOrderId,
+    raw: data
+  });
+  if (responseCode === "Error") {
+    throw new AzulResponseError(`Error de sistema de AZUL: ${errorDescription ?? "sin descripci\xF3n"}`, data);
+  }
+  if (responseCode === "ISO8583") {
+    if (isoCode === "00") return build("approved");
+    if (isoCode === "3D" || isoCode === "3D2METHOD") return build("requires_3ds");
+    return build("declined");
+  }
+  if (errorDescription?.includes("SGS-")) {
+    if (SYSTEM_GATEWAY_ERRORS.some((e) => errorDescription.includes(e))) {
+      throw new AzulResponseError(`Error de gateway de AZUL: ${errorDescription}`, data);
+    }
+    return build("declined");
+  }
+  const errorMessage = str(data.ErrorMessage);
+  if (errorMessage) {
+    throw new AzulResponseError(`Error de API de AZUL: ${errorMessage}`, data);
+  }
+  if (isoCode === "00") return build("approved");
+  if (isoCode) return build("declined");
+  throw new AzulResponseError("Respuesta de AZUL con estructura desconocida", data);
+}
+
+// src/transport.ts
+var import_undici = require("undici");
+
+// src/redact.ts
+var DROP = /* @__PURE__ */ new Set(["CVC", "Auth1", "Auth2"]);
+var MASK_PAN = /* @__PURE__ */ new Set(["CardNumber"]);
+var MASK_PARTIAL = /* @__PURE__ */ new Set(["DataVaultToken"]);
+function maskPan(pan) {
+  const digits = pan.replace(/\D/g, "");
+  if (digits.length < 10) return digits.length === 0 ? "" : "****";
+  return `${digits.slice(0, 6)}${"*".repeat(digits.length - 10)}${digits.slice(-4)}`;
+}
+function redact(payload) {
+  const out = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (DROP.has(key)) {
+      if (value !== void 0 && value !== "") out[key] = "[censurado]";
+      continue;
+    }
+    if (MASK_PAN.has(key) && typeof value === "string") {
+      out[key] = maskPan(value);
+      continue;
+    }
+    if (MASK_PARTIAL.has(key) && typeof value === "string" && value.length > 8) {
+      out[key] = `${value.slice(0, 4)}\u2026${value.slice(-4)}`;
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// src/transport.ts
+var CONNECT_PHASE_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+function errorCode(err) {
+  if (err && typeof err === "object") {
+    const code = err.code;
+    if (typeof code === "string") return code;
+    const cause = err.cause;
+    if (cause && cause !== err) return errorCode(cause);
+  }
+  return void 0;
+}
+function isConnectPhaseError(err) {
+  const code = errorCode(err);
+  return code !== void 0 && CONNECT_PHASE_CODES.has(code);
+}
+var AzulTransport = class {
+  constructor(config) {
+    this.config = config;
+    if (config.dispatcher) {
+      this.dispatcher = config.dispatcher;
+      this.ownsDispatcher = false;
+    } else {
+      this.dispatcher = new import_undici.Agent({
+        connect: {
+          cert: config.certificate,
+          key: config.privateKey,
+          timeout: Math.min(1e4, config.timeoutMs)
+        }
+      });
+      this.ownsDispatcher = true;
+    }
+  }
+  config;
+  dispatcher;
+  ownsDispatcher;
+  async close() {
+    if (this.ownsDispatcher) await this.dispatcher.close();
+  }
+  async send(payload, options) {
+    const urls = [this.config.webservicesUrl];
+    if (this.config.webservicesAlternaUrl) urls.push(this.config.webservicesAlternaUrl);
+    let lastError;
+    for (let i = 0; i < urls.length; i++) {
+      const base = urls[i];
+      const url = options.operation ? `${base}?${options.operation}` : base;
+      const hasFallback = i < urls.length - 1;
+      this.config.onRequest?.({ operation: options.name, url, payload: redact(payload) });
+      let statusCode;
+      let text;
+      try {
+        const res = await (0, import_undici.request)(url, {
+          method: "POST",
+          dispatcher: this.dispatcher,
+          headers: {
+            "content-type": "application/json",
+            Auth1: this.config.auth1,
+            Auth2: this.config.auth2
+          },
+          body: JSON.stringify(payload),
+          headersTimeout: this.config.timeoutMs,
+          bodyTimeout: this.config.timeoutMs
+        });
+        statusCode = res.statusCode;
+        text = await res.body.text();
+      } catch (err) {
+        lastError = err;
+        if (isConnectPhaseError(err)) {
+          if (hasFallback) continue;
+          throw new AzulError(`No se pudo conectar con AZUL (${options.name}). La solicitud no se envi\xF3.`, { cause: err });
+        }
+        if (options.idempotent && hasFallback) continue;
+        throw this.ambiguous(options, `fallo de red despu\xE9s de enviar la solicitud (${errorCode(err) ?? "desconocido"})`, err);
+      }
+      if (statusCode >= 500) {
+        lastError = new AzulHttpError(`HTTP ${statusCode}`, statusCode, text);
+        if (options.idempotent && hasFallback) continue;
+        throw this.ambiguous(options, `AZUL respondi\xF3 HTTP ${statusCode}`, lastError);
+      }
+      if (statusCode >= 400) {
+        throw new AzulHttpError(`AZUL rechaz\xF3 la solicitud ${options.name} con HTTP ${statusCode}`, statusCode, text);
+      }
+      let data;
+      try {
+        data = JSON.parse(text);
+      } catch (err) {
+        if (options.idempotent && hasFallback) {
+          lastError = err;
+          continue;
+        }
+        throw this.ambiguous(options, "AZUL devolvi\xF3 una respuesta que no es JSON v\xE1lido", err);
+      }
+      if (!data || typeof data !== "object" || Array.isArray(data)) {
+        throw this.ambiguous(options, "AZUL devolvi\xF3 una respuesta vac\xEDa o con formato inesperado", void 0);
+      }
+      const record = data;
+      this.config.onResponse?.({ operation: options.name, url, payload: redact(record) });
+      return record;
+    }
+    if (isConnectPhaseError(lastError)) {
+      throw new AzulError(`No se pudo conectar con AZUL (${options.name}). La solicitud no se envi\xF3.`, { cause: lastError });
+    }
+    throw this.ambiguous(options, "todas las URLs de AZUL fallaron", lastError);
+  }
+  ambiguous(options, reason, cause) {
+    const hint = options.customOrderId ? ` Consulta el estado con verifyPayment({ customOrderId: "${options.customOrderId}" }) antes de reintentar.` : " Verifica el estado en el portal de AZUL antes de reintentar.";
+    return new AzulAmbiguousError(
+      `Resultado desconocido para ${options.name}: ${reason}. Es posible que AZUL s\xED la haya procesado.${hint}`,
+      options.customOrderId,
+      { cause }
+    );
+  }
+};
+
+// src/client.ts
+var AzulClient = class {
+  config;
+  transport;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    this.transport = new AzulTransport(this.config);
+  }
+  /** Cierra las conexiones abiertas. Llámalo al apagar tu servidor. */
+  async close() {
+    await this.transport.close();
+  }
+  // ---------------------------------------------------------------- ventas
+  /**
+   * Venta directa con datos de tarjeta.
+   *
+   * OJO: recibir el número de tarjeta en tu servidor te pone dentro del
+   * alcance de PCI DSS. Si puedes, usa la Página de Pagos (paymentPage) o
+   * cobra con un token de DataVault (tokenSale).
+   */
+  async sale(input) {
+    return this.cardTransaction("Sale", input);
+  }
+  /** Pre-autorización: retiene el monto sin cobrarlo. Captúralo luego con capture(). */
+  async hold(input) {
+    return this.cardTransaction("Hold", input);
+  }
+  /** Venta con una tarjeta guardada en DataVault. */
+  async tokenSale(input) {
+    const order = this.orderFields(input);
+    const payload = {
+      ...this.base(),
+      ...order.fields,
+      TrxType: "Sale",
+      PosInputMode: "E-Commerce",
+      CardNumber: "",
+      Expiration: "",
+      DataVaultToken: dataVaultToken(input.dataVaultToken),
+      ...input.cvc ? { CVC: cvc(input.cvc) } : {}
+    };
+    const data = await this.transport.send(payload, {
+      operation: "",
+      name: "tokenSale",
+      idempotent: false,
+      customOrderId: order.customOrderId
+    });
+    return interpretResponse(data, order.customOrderId);
+  }
+  // ------------------------------------------------- después de la venta
+  /** Captura (total o parcial) una pre-autorización hecha con hold(). */
+  async capture(input) {
+    const payload = {
+      ...this.base(),
+      AzulOrderId: azulOrderId(input.azulOrderId),
+      Amount: centsToAzul(input.amount, "amount"),
+      Itbis: itbisToAzul(input.itbis)
+    };
+    const data = await this.transport.send(payload, { operation: "ProcessPost", name: "capture", idempotent: false });
+    return interpretResponse(data);
+  }
+  /** Anula una transacción del mismo día (antes del cierre de lote). */
+  async void(input) {
+    const payload = { ...this.base(), AzulOrderId: azulOrderId(input.azulOrderId) };
+    const data = await this.transport.send(payload, { operation: "ProcessVoid", name: "void", idempotent: false });
+    return interpretResponse(data);
+  }
+  /** Reembolsa (total o parcialmente) una venta ya liquidada. */
+  async refund(input) {
+    const customOrderId = this.customOrderId(input.customOrderId);
+    const payload = {
+      ...this.base(),
+      TrxType: "Refund",
+      PosInputMode: "E-Commerce",
+      AzulOrderId: azulOrderId(input.azulOrderId),
+      Amount: centsToAzul(input.amount, "amount"),
+      Itbis: itbisToAzul(input.itbis),
+      OrderNumber: maxText(input.orderNumber, "orderNumber", 15, { required: true }),
+      CustomOrderId: customOrderId
+    };
+    const data = await this.transport.send(payload, {
+      operation: "",
+      name: "refund",
+      idempotent: false,
+      customOrderId
+    });
+    return interpretResponse(data, customOrderId);
+  }
+  /**
+   * Consulta el estado de una transacción hecha por la API (ProcessPayment) por
+   * su customOrderId. Es la forma correcta de salir de la duda después de un
+   * AzulAmbiguousError. Si hay varias con el mismo id, AZUL devuelve la última.
+   * Si no existe, AZUL responde Found=false y aquí se devuelve `{ found: false }`.
+   */
+  async verifyPayment(input) {
+    const customOrderId = maxText(input.customOrderId, "customOrderId", 75, { required: true });
+    const data = await this.transport.send(
+      { ...this.base(), CustomOrderId: customOrderId },
+      { operation: "VerifyPayment", name: "verifyPayment", idempotent: true, customOrderId }
+    );
+    const found = data.Found;
+    if ((found === false || found === "false" || found === "False") && data.ResponseCode !== "Error") {
+      return { found: false, customOrderId, raw: data };
+    }
+    return { found: true, ...interpretResponse(data, customOrderId) };
+  }
+  // ------------------------------------------------------------- DataVault
+  dataVault = {
+    /** Guarda una tarjeta y devuelve un token reutilizable. */
+    create: async (input) => {
+      const payload = {
+        ...this.base(),
+        TrxType: "CREATE",
+        CardNumber: cardNumber(input.cardNumber),
+        Expiration: expiration(input.expiration),
+        CVC: cvc(input.cvc)
+      };
+      const data = await this.transport.send(payload, {
+        operation: "ProcessDatavault",
+        name: "dataVault.create",
+        idempotent: false
+      });
+      return toDataVaultResult(data);
+    },
+    /** Elimina un token de DataVault. */
+    delete: async (input) => {
+      const payload = { ...this.base(), TrxType: "DELETE", DataVaultToken: dataVaultToken(input.dataVaultToken) };
+      const data = await this.transport.send(payload, {
+        operation: "ProcessDatavault",
+        name: "dataVault.delete",
+        idempotent: true
+      });
+      return toDataVaultResult(data);
+    }
+  };
+  // ------------------------------------------------------- Página de Pagos
+  /**
+   * Prepara el formulario para redirigir al cliente a la Página de Pagos de
+   * AZUL. Con esta vía tu servidor nunca ve el número de tarjeta.
+   */
+  paymentPage(input) {
+    if (!this.config.paymentPage) {
+      throw new AzulConfigError("Para usar la P\xE1gina de Pagos configura paymentPage: { authKey, merchantName, merchantType }.");
+    }
+    return buildPaymentPage(input, {
+      merchantId: this.config.merchantId,
+      url: this.config.paymentPageUrl,
+      ...this.config.paymentPage
+    });
+  }
+  // -------------------------------------------------------------- internos
+  base() {
+    return { Channel: this.config.channel, Store: this.config.merchantId };
+  }
+  customOrderId(value) {
+    return maxText(value, "customOrderId", 75) ?? (0, import_node_crypto2.randomUUID)();
+  }
+  orderFields(input) {
+    const customOrderId = this.customOrderId(input.customOrderId);
+    const fields = {
+      Amount: centsToAzul(input.amount, "amount"),
+      Itbis: itbisToAzul(input.itbis),
+      OrderNumber: maxText(input.orderNumber, "orderNumber", 15, { required: true }),
+      CustomOrderId: customOrderId
+    };
+    const alt = maxText(input.altMerchantName, "altMerchantName", 25);
+    if (alt) fields.AltMerchantName = alt;
+    if (input.forceNo3DS) fields.ForceNo3DS = "1";
+    if (input.itbis !== void 0 && input.itbis > input.amount) {
+      throw new AzulValidationError("itbis no puede ser mayor que amount: amount es el total con ITBIS incluido.", ["itbis"]);
+    }
+    return { customOrderId, fields };
+  }
+  async cardTransaction(trxType, input) {
+    const order = this.orderFields(input);
+    const payload = {
+      ...this.base(),
+      ...order.fields,
+      TrxType: trxType,
+      PosInputMode: "E-Commerce",
+      CardNumber: cardNumber(input.cardNumber),
+      Expiration: expiration(input.expiration),
+      CVC: cvc(input.cvc),
+      SaveToDataVault: input.saveToDataVault ? "1" : "0"
+    };
+    const data = await this.transport.send(payload, {
+      operation: "",
+      name: trxType === "Sale" ? "sale" : "hold",
+      idempotent: false,
+      customOrderId: order.customOrderId
+    });
+    return interpretResponse(data, order.customOrderId);
+  }
+};
+function toDataVaultResult(data) {
+  const s = (k) => typeof data[k] === "string" && data[k] !== "" ? data[k] : void 0;
+  const result = interpretResponse(data);
+  return {
+    status: result.status === "approved" ? "approved" : "declined",
+    dataVaultToken: s("DataVaultToken"),
+    maskedCardNumber: s("CardNumber"),
+    brand: s("DataVaultBrand"),
+    expiration: s("DataVaultExpiration"),
+    hasCvv: data.HasCVV === true || data.HasCVV === "true",
+    isoCode: result.isoCode,
+    message: result.message,
+    errorDescription: result.errorDescription,
+    raw: data
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AZUL_URLS,
+  AzulAmbiguousError,
+  AzulClient,
+  AzulConfigError,
+  AzulError,
+  AzulHttpError,
+  AzulResponseError,
+  AzulValidationError,
+  PAYMENT_PAGE_HASH_FIELDS,
+  PAYMENT_PAGE_RESPONSE_HASH_FIELDS,
+  defaultPaymentPageHash,
+  escapeHtml,
+  maskPan,
+  passesLuhn,
+  paymentPageResponseHash,
+  redact,
+  toCents,
+  verifyPaymentPageResponse
+});
+//# sourceMappingURL=index.cjs.map