@agent-cards/sdk 0.23.12 → 0.23.14

package/dist/creditguard.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 58593275ccbce7e76a1aa68065eb63063cdf0ed00d533706bec557cb8a21cbc8
+// artifact-sha256: 0110d9fe2e862aad2c1191c5927ebb98dcc4be9905554ed46e18719a0bad05fb
 // src/creditguard.js
 var CREDITGUARD_PPS_HOSTS = Object.freeze(["pps.creditguard.co.il", "pps2.creditguard.co.il", "ppsuat.creditguard.co.il"]);
 var CREDITGUARD_SANDBOX_HOST = "ppsuat.creditguard.co.il";
@@ -516,8 +516,11 @@ function parseCreditguardTransaction(body, txId) {
     const inputData = record(value.formConfig) && Array.isArray(value.formConfig.inputData) ? value.formConfig.inputData : [];
     const inputs = inputData.length <= 32 && inputData.every((input) => record(input) && exact(INPUT_NAMES, input.inputName) && inputFlag(input.required) && inputFlag(input.visible)) ? inputData.map((input) => ({ inputName: input.inputName, required: input.required === true, visible: input.visible === true })) : null;
     let jwePublicKey = "absent";
+    let jwePublicKeyJson = null;
     if (owns(trx, "jwePublicKey") && trx.jwePublicKey !== null && trx.jwePublicKey !== "") {
         jwePublicKey = parseCreditguardJwePublicKey(trx.jwePublicKey) ?? "malformed";
+        if (jwePublicKey !== "malformed")
+            jwePublicKeyJson = typeof trx.jwePublicKey === "string" ? trx.jwePublicKey : JSON.stringify(trx.jwePublicKey);
     }
     return {
         txId,
@@ -535,6 +538,7 @@ function parseCreditguardTransaction(body, txId) {
         dccActive: flag(trx.dccActive),
         recaptcha: ["googleRecaptchaKey", "googleRecaptchaV3Key"].some((key) => typeof trx[key] === "string" && trx[key] !== ""),
         jwePublicKey,
+        jwePublicKeyJson,
         personalIdAlwaysEnabled: flag(ui.personalIdAlwaysEnabled),
         inputs
     };
@@ -557,7 +561,7 @@ function formInputsRefusal(inputs) {
 function creditguardTransactionRefusal(txn, expectation) {
     if (!record(txn) || !record(expectation))
         return "transaction_unreadable";
-    if (txn.threeDS)
+    if (txn.threeDS && !(expectation.threeDS === "device" && txn.threeDSProvider === "cc" && !txn.recaptcha))
         return "three_d_secure";
     if (txn.otpActive)
         return "otp";
@@ -594,6 +598,12 @@ function creditguardSendWindowRefusal(timing) {
         return "recaptcha_expired";
     return null;
 }
+function creditguardBodyTransactionRefusal(body, txn) {
+    const value = readCreditguardJson(body);
+    if (!value || !record(txn))
+        return null;
+    return owns(value, "jwePayload") === (txn.jwePublicKey !== "absent") ? null : "jwe_mismatch";
+}
 var ERROR_CODE = /^-?[0-9]{1,4}$/;
 var CREDITGUARD_REFUSAL_CODES = Object.freeze(["681", "682", "683", "687", "689"]);
 function landingUrl(value) {
@@ -657,4 +667,324 @@ function creditguardFacts(status, body) {
         refusalCode: verdict.outcome === "refused" ? verdict.code : null
     };
 }
-export { CREDITGUARD_JWE_HEADER, CREDITGUARD_OPERATION, CREDITGUARD_PAGE_WINDOW_MS, CREDITGUARD_PPS_HOSTS, CREDITGUARD_RECAPTCHA_WINDOW_MS, CREDITGUARD_REFUSAL_CODES, CREDITGUARD_SANDBOX_HOST, classifyCreditguardRequest, creditguardBodyRefusal, creditguardFacts, creditguardNuveiRefusal, creditguardPageProcessUrl, creditguardPpDomainHost, creditguardPreparationEnvironment, creditguardProcessRefusal, creditguardProcessTxId, creditguardRefusalMessage, creditguardReplayRefusal, creditguardResponseOutcome, creditguardSendWindowRefusal, creditguardTransactionReadUrl, creditguardTransactionRefusal, encryptCreditguardJwe, injectCreditguardCard, injectCreditguardJweCard, isCreditguardJweCompact, isCreditguardPpsDocument, isCreditguardProcessRequest, isCreditguardProcessUrl, parseCreditguardJwePublicKey, parseCreditguardTransaction, readCreditguardJson, sanitizeCreditguardResponse };
+var CREDITGUARD_COMPANION_PATHS = Object.freeze({
+    card_details: "/card/details",
+    ddc_init: "/cc/ddc/init",
+    threeds_init: "/cg3ds/process/init",
+    threeds_outcome: "/cg3ds/process/outcome"
+});
+var CREDITGUARD_DEVICE_STEPS = Object.freeze(["ddc_init", "threeds_init", "threeds_outcome"]);
+var CREDITGUARD_CARDINAL_HOSTS = Object.freeze({
+    production: Object.freeze(["client.cardinaltrusted.com", "centinelapi.cardinalcommerce.com"]),
+    sandbox: Object.freeze(["cas.client.cardinaltrusted.com", "centinelapistag.cardinalcommerce.com"])
+});
+var CREDITGUARD_CARDINAL_COLLECT_URLS = Object.freeze({
+    production: "https://client.cardinaltrusted.com/centinelapi/V2/Cruise/Collect",
+    sandbox: "https://cas.client.cardinaltrusted.com/centinelapi/V2/Cruise/Collect"
+});
+var CARDINAL_PATHS = Object.freeze({
+    collect: /^\/(?:centinelapi\/)?V[12]\/Cruise\/Collect$/,
+    step_up: /^\/(?:centinelapi\/)?V[12]\/Cruise\/StepUp$/
+});
+var COMPANION_PATH = new RegExp(`^/services/v1/txn/(${UUID})(/card/details|/cc/ddc/init|/cg3ds/process/init|/cg3ds/process/outcome)$`);
+var COMPANION_ENDPOINT = /^\/services\/v1\/txn\/[^/]+\/(?:card\/details|cc\/ddc\/init|cg3ds\/process\/(?:init|outcome))\/?$/i;
+var STEP_BY_PATH = Object.freeze(Object.fromEntries(Object.entries(CREDITGUARD_COMPANION_PATHS).map(([step, path]) => [path, step])));
+var COMPANION_ANSWERS = Object.freeze({
+    card_details: '{"creditCompany":"Foreign","cardType":"Foreign"}',
+    ddc_init: "{}",
+    threeds_init: '{"challengeRequired":false}',
+    threeds_outcome: "{}"
+});
+var JWT = /^[A-Za-z0-9_-]{2,4096}\.[A-Za-z0-9_-]{2,4096}\.[A-Za-z0-9_-]{0,1024}$/;
+var SESSION_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+var LANGUAGE = /^[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8}){0,4}$/;
+var THREE_DS_REFUSAL = "Refusing to pay: this CreditGuard 3-D Secure step is not the reviewed one. Nothing was sent.";
+var BROWSER_HEADER = "text/html;charset=UTF-8";
+var THREE_DS_INIT_KEYS = Object.freeze([
+    "cardNumber",
+    "expMonth",
+    "expYear",
+    "cvv",
+    "isGooglePayTxn",
+    "isPayboxTxn",
+    "useDcc",
+    "acsWindowSize",
+    "browserColorDepth",
+    "browserHeader",
+    "browserJavaEnabled",
+    "browserJavascriptEnabled",
+    "browserLanguage",
+    "browserScreenHeight",
+    "browserScreenWidth",
+    "browserTimeZone",
+    "txId",
+    "pendingGiftCards",
+    "userAgent",
+    "jwePublicKey",
+    "ccDdcSessionId"
+]);
+var DEVICE_HEADERS = Object.freeze({ "content-type": "application/json", accept: "application/json" });
+function creditguardCompanionStep(url) {
+    if (typeof url !== "string" || url.includes("?") || url.includes("#"))
+        return null;
+    const parsed = httpsUrl(url);
+    if (!parsed || parsed.href !== url || !CREDITGUARD_PPS_HOSTS.includes(parsed.hostname))
+        return null;
+    const match = COMPANION_PATH.exec(parsed.pathname);
+    return match ? { step: STEP_BY_PATH[match[2]], txId: match[1] } : null;
+}
+function isCompanionEndpoint(url) {
+    const parsed = httpsUrl(url, 4096);
+    return !!parsed && CREDITGUARD_PPS_HOSTS.includes(parsed.hostname.toLowerCase()) && COMPANION_ENDPOINT.test(parsed.pathname);
+}
+function creditguardDeviceStepUrl(processUrl, step) {
+    const txId = creditguardProcessTxId(processUrl);
+    if (txId === null || !CREDITGUARD_DEVICE_STEPS.includes(step))
+        return null;
+    return `https://${new URL(processUrl).hostname}/services/v1/txn/${txId}${CREDITGUARD_COMPANION_PATHS[step]}`;
+}
+function companionBodyRefusal(step, txId, body) {
+    if (step === "threeds_outcome")
+        return body === "null" || readCreditguardJson(body) ? null : "malformed_body";
+    const value = readCreditguardJson(body);
+    if (!value)
+        return "malformed_body";
+    if (step === "card_details") {
+        const keys = Object.keys(value);
+        if (keys.length !== 1)
+            return "malformed_body";
+        if (keys[0] === "cardNo")
+            return digits(value.cardNo, 12, 19) ? null : "card_fields";
+        return keys[0] === "cardNoEnc" && isCreditguardJweCompact(value.cardNoEnc) ? null : "malformed_body";
+    }
+    if (step === "ddc_init") {
+        if (value.isGooglePayTxn === true)
+            return "wallet";
+        if (value.isGooglePayTxn !== false || Object.keys(value).some((key) => !["cardNo", "encryptedCardNo", "isGooglePayTxn"].includes(key)))
+            return "malformed_body";
+        if (owns(value, "cardNo"))
+            return digits(value.cardNo, 12, 19) && value.encryptedCardNo === null ? null : "card_fields";
+        return isCreditguardJweCompact(value.encryptedCardNo) ? null : "card_fields";
+    }
+    if (value.isGooglePayTxn === true || value.isPayboxTxn === true)
+        return "wallet";
+    if (value.pendingGiftCards === true)
+        return "gift_card";
+    if (value.useDcc === true)
+        return "dcc";
+    if (owns(value, "txId") && value.txId !== txId)
+        return "txid_mismatch";
+    return digits(value.cardNumber, 12, 19) ? null : "card_fields";
+}
+function creditguardCompanionCall(url, method, body) {
+    if (!isCompanionEndpoint(url))
+        return null;
+    const exactStep = creditguardCompanionStep(url);
+    if (exactStep === null)
+        return { step: null, txId: null, refusal: "not_companion_request" };
+    if (method !== "POST")
+        return { ...exactStep, refusal: "not_companion_request" };
+    return { ...exactStep, refusal: companionBodyRefusal(exactStep.step, exactStep.txId, body) };
+}
+function creditguardCompanionAnswer(step) {
+    return typeof step === "string" && owns(COMPANION_ANSWERS, step) ? { status: 200, headers: { "content-type": "application/json" }, body: COMPANION_ANSWERS[step] } : null;
+}
+function deviceBrowser(browser) {
+    const int = (value, min, max) => Number.isSafeInteger(value) && value >= min && value <= max;
+    if (!record(browser) || !int(browser.colorDepth, 1, 64) || typeof browser.javaEnabled !== "boolean" || !exact(LANGUAGE, browser.language) || !int(browser.screenHeight, 1, 1e5) || !int(browser.screenWidth, 1, 1e5) || !int(browser.timeZoneOffset, -900, 900) || typeof browser.userAgent !== "string" || browser.userAgent.length < 1 || browser.userAgent.length > 1024 || /[^\x20-\x7e]/.test(browser.userAgent)) {
+        throw new Error(THREE_DS_REFUSAL);
+    }
+    return {
+        colorDepth: browser.colorDepth,
+        javaEnabled: browser.javaEnabled,
+        language: browser.language,
+        screenHeight: browser.screenHeight,
+        screenWidth: browser.screenWidth,
+        timeZoneOffset: browser.timeZoneOffset,
+        userAgent: browser.userAgent
+    };
+}
+function deviceKey(key) {
+    if (key === void 0 || key === null)
+        return null;
+    if (typeof key !== "string" || !parseCreditguardJwePublicKey(key))
+        throw new Error(THREE_DS_REFUSAL);
+    return { text: key, object: JSON.parse(key) };
+}
+async function creditguardDeviceDdcRequest(processUrl, card, options = {}) {
+    const url = creditguardDeviceStepUrl(processUrl, "ddc_init");
+    if (!url)
+        throw new Error(THREE_DS_REFUSAL);
+    const parts = cardParts(card);
+    const key = deviceKey(record(options) ? options.jwePublicKey : void 0);
+    const body = key === null ? JSON.stringify({ cardNo: parts.number, encryptedCardNo: null, isGooglePayTxn: false }) : JSON.stringify({ encryptedCardNo: await encryptCreditguardJwe(parts.number, key.text, options), isGooglePayTxn: false });
+    return { url, method: "POST", headers: { ...DEVICE_HEADERS }, body };
+}
+function creditguardDeviceThreeDSInitRequest(processUrl, card, options = {}) {
+    const url = creditguardDeviceStepUrl(processUrl, "threeds_init");
+    if (!url || !record(options))
+        throw new Error(THREE_DS_REFUSAL);
+    const parts = cardParts(card);
+    const browser = deviceBrowser(options.browser);
+    const key = deviceKey(options.jwePublicKey);
+    const session = options.ddcSessionId ?? null;
+    if (session !== null && !exact(SESSION_ID, session))
+        throw new Error(THREE_DS_REFUSAL);
+    const body = {
+        cardNumber: parts.number,
+        expMonth: parts.month,
+        expYear: parts.year,
+        cvv: parts.cvc,
+        isGooglePayTxn: false,
+        isPayboxTxn: false,
+        useDcc: false,
+        acsWindowSize: "4",
+        browserColorDepth: browser.colorDepth,
+        browserHeader: BROWSER_HEADER,
+        browserJavaEnabled: browser.javaEnabled,
+        browserJavascriptEnabled: true,
+        browserLanguage: browser.language,
+        browserScreenHeight: browser.screenHeight,
+        browserScreenWidth: browser.screenWidth,
+        browserTimeZone: browser.timeZoneOffset,
+        txId: creditguardProcessTxId(processUrl),
+        pendingGiftCards: false,
+        userAgent: browser.userAgent,
+        jwePublicKey: key === null ? "" : key.object,
+        ccDdcSessionId: session
+    };
+    return { url, method: "POST", headers: { ...DEVICE_HEADERS }, body: JSON.stringify(body) };
+}
+function creditguardDeviceThreeDSOutcomeRequest(processUrl) {
+    const url = creditguardDeviceStepUrl(processUrl, "threeds_outcome");
+    if (!url)
+        throw new Error(THREE_DS_REFUSAL);
+    return { url, method: "POST", headers: { ...DEVICE_HEADERS }, body: "null" };
+}
+function deviceStepBodyRefusal(step, txId, body) {
+    if (step === "threeds_outcome")
+        return body === "null" ? null : "malformed_body";
+    const value = readCreditguardJson(body);
+    if (!value)
+        return "malformed_body";
+    const keys = Object.keys(value).join(",");
+    if (step === "ddc_init") {
+        if (keys === "cardNo,encryptedCardNo,isGooglePayTxn")
+            return digits(value.cardNo, 12, 19) && value.encryptedCardNo === null && value.isGooglePayTxn === false ? null : "card_fields";
+        if (keys === "encryptedCardNo,isGooglePayTxn")
+            return isCreditguardJweCompact(value.encryptedCardNo) && value.isGooglePayTxn === false ? null : "card_fields";
+        return "unexpected_field";
+    }
+    if (keys !== THREE_DS_INIT_KEYS.join(","))
+        return "unexpected_field";
+    if (!digits(value.cardNumber, 12, 19) || !exact(/^(?:0[1-9]|1[0-2])$/, value.expMonth) || !exact(/^[0-9]{2}$/, value.expYear) || !digits(value.cvv, 3, 4))
+        return "card_fields";
+    if (value.isGooglePayTxn !== false || value.isPayboxTxn !== false)
+        return "wallet";
+    if (value.pendingGiftCards !== false)
+        return "gift_card";
+    if (value.useDcc !== false)
+        return "dcc";
+    if (value.txId !== txId)
+        return "txid_mismatch";
+    if (value.acsWindowSize !== "4" || value.browserHeader !== BROWSER_HEADER || value.browserJavascriptEnabled !== true)
+        return "malformed_body";
+    try {
+        deviceBrowser({
+            colorDepth: value.browserColorDepth,
+            javaEnabled: value.browserJavaEnabled,
+            language: value.browserLanguage,
+            screenHeight: value.browserScreenHeight,
+            screenWidth: value.browserScreenWidth,
+            timeZoneOffset: value.browserTimeZone,
+            userAgent: value.userAgent
+        });
+    }
+    catch {
+        return "malformed_body";
+    }
+    if (value.jwePublicKey !== "" && !(record(value.jwePublicKey) && parseCreditguardJwePublicKey(value.jwePublicKey)))
+        return "malformed_body";
+    return value.ccDdcSessionId === null || exact(SESSION_ID, value.ccDdcSessionId) ? null : "malformed_body";
+}
+function creditguardDeviceStepRefusal(request, processUrl) {
+    if (!record(request) || request.method !== "POST")
+        return "not_companion_request";
+    const exactStep = creditguardCompanionStep(request.url);
+    if (!exactStep || creditguardDeviceStepUrl(processUrl, exactStep.step) !== request.url)
+        return "not_companion_request";
+    if (!record(request.headers))
+        return "headers";
+    const names = Object.keys(request.headers).map((name) => name.toLowerCase()).sort().join(",");
+    if (names !== "accept,content-type" || headersRefusal(request.headers) !== null)
+        return "headers";
+    return deviceStepBodyRefusal(exactStep.step, exactStep.txId, request.body);
+}
+function creditguardCardinalUrl(url, purpose, environment) {
+    const hosts = typeof environment === "string" && owns(CREDITGUARD_CARDINAL_HOSTS, environment) ? CREDITGUARD_CARDINAL_HOSTS[environment] : null;
+    const path = typeof purpose === "string" && owns(CARDINAL_PATHS, purpose) ? CARDINAL_PATHS[purpose] : null;
+    if (!hosts || !path || typeof url !== "string" || url.includes("?") || url.includes("#"))
+        return null;
+    const parsed = httpsUrl(url, 1024);
+    return parsed && parsed.href === url && hosts.includes(parsed.hostname) && path.test(parsed.pathname) ? parsed.href : null;
+}
+function isCreditguardCardinalOrigin(origin) {
+    if (typeof origin !== "string" || origin.length > 256)
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(origin);
+    }
+    catch {
+        return false;
+    }
+    return parsed.protocol === "https:" && parsed.origin === origin && !parsed.port && /(?:^|\.)(?:cardinaltrusted|cardinalcommerce)\.com$/.test(parsed.hostname);
+}
+function creditguardCardinalMessage(data) {
+    if (typeof data !== "string" || data.length > 16384)
+        return null;
+    let value;
+    try {
+        value = JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+    if (!record(value))
+        return null;
+    const payload = value.Payload || value.TransactionId;
+    return { sessionId: record(payload) && exact(SESSION_ID, payload.SessionId) ? payload.SessionId : null };
+}
+function creditguardDdcAnswer(status, body, environment) {
+    if (status !== 200)
+        return null;
+    const value = readCreditguardJson(body);
+    if (!value || typeof value.ddcJwt !== "string" || value.ddcJwt.length > 8192 || !JWT.test(value.ddcJwt))
+        return null;
+    const named = typeof value.clientDdcUrl === "string" && value.clientDdcUrl !== "" ? value.clientDdcUrl : null;
+    if (named === null && !absent(value, "clientDdcUrl") && value.clientDdcUrl !== "")
+        return null;
+    const collectUrl = named === null ? typeof environment === "string" && owns(CREDITGUARD_CARDINAL_COLLECT_URLS, environment) ? CREDITGUARD_CARDINAL_COLLECT_URLS[environment] : null : creditguardCardinalUrl(named, "collect", environment);
+    return collectUrl ? { collectUrl, ddcJwt: value.ddcJwt } : null;
+}
+function creditguardThreeDSInitAnswer(status, body, environment) {
+    if (status !== 200)
+        return { outcome: "stop", reason: "threeds_init_status" };
+    const value = readCreditguardJson(body);
+    if (!value)
+        return { outcome: "stop", reason: "threeds_init_unreadable" };
+    if (value.challengeRequired !== true)
+        return { outcome: "frictionless" };
+    const stepUpUrl = creditguardCardinalUrl(value.stepUpUrl, "step_up", environment);
+    if (!stepUpUrl || typeof value.stepUpJwt !== "string" || value.stepUpJwt.length > 8192 || !JWT.test(value.stepUpJwt)) {
+        return { outcome: "stop", reason: "threeds_step_up_unreviewed" };
+    }
+    return { outcome: "challenge", stepUpUrl, stepUpJwt: value.stepUpJwt };
+}
+function creditguardThreeDSOutcomeAnswer(status, body) {
+    const value = status === 200 ? readCreditguardJson(body) : null;
+    if (!value)
+        return { outcome: "stop", reason: "threeds_outcome_unreadable" };
+    return value.cancelled === true ? { outcome: "stop", reason: "threeds_cancelled" } : { outcome: "authenticated" };
+}
+export { CREDITGUARD_CARDINAL_COLLECT_URLS, CREDITGUARD_CARDINAL_HOSTS, CREDITGUARD_COMPANION_PATHS, CREDITGUARD_DEVICE_STEPS, CREDITGUARD_JWE_HEADER, CREDITGUARD_OPERATION, CREDITGUARD_PAGE_WINDOW_MS, CREDITGUARD_PPS_HOSTS, CREDITGUARD_RECAPTCHA_WINDOW_MS, CREDITGUARD_REFUSAL_CODES, CREDITGUARD_SANDBOX_HOST, classifyCreditguardRequest, creditguardBodyRefusal, creditguardBodyTransactionRefusal, creditguardCardinalMessage, creditguardCardinalUrl, creditguardCompanionAnswer, creditguardCompanionCall, creditguardCompanionStep, creditguardDdcAnswer, creditguardDeviceDdcRequest, creditguardDeviceStepRefusal, creditguardDeviceStepUrl, creditguardDeviceThreeDSInitRequest, creditguardDeviceThreeDSOutcomeRequest, creditguardFacts, creditguardNuveiRefusal, creditguardPageProcessUrl, creditguardPpDomainHost, creditguardPreparationEnvironment, creditguardProcessRefusal, creditguardProcessTxId, creditguardRefusalMessage, creditguardReplayRefusal, creditguardResponseOutcome, creditguardSendWindowRefusal, creditguardThreeDSInitAnswer, creditguardThreeDSOutcomeAnswer, creditguardTransactionReadUrl, creditguardTransactionRefusal, encryptCreditguardJwe, injectCreditguardCard, injectCreditguardJweCard, isCreditguardCardinalOrigin, isCreditguardJweCompact, isCreditguardPpsDocument, isCreditguardProcessRequest, isCreditguardProcessUrl, parseCreditguardJwePublicKey, parseCreditguardTransaction, readCreditguardJson, sanitizeCreditguardResponse };

package/dist/datatrans.generated.d.ts

@@ -6,9 +6,15 @@ declare var DATATRANS_CARD_ON_FILE_REFUSED: string;
 declare var DATATRANS_REGISTRATION_POLICIES: readonly string[];
 declare var DATATRANS_REGISTRATION_POLICY: string;
 declare var DATATRANS_REVIEWED_MERCHANT_IDS: Readonly<{
-    "pay.datatrans.com": readonly never[];
+    "pay.datatrans.com": readonly string[];
     "pay.sandbox.datatrans.com": readonly string[];
 }>;
+declare var DATATRANS_MERCHANT_ACCOUNT_NAMES: Readonly<{
+    "pay.datatrans.com": Readonly<{
+        "3000022877": "RaiseNow";
+    }>;
+    "pay.sandbox.datatrans.com": Readonly<{}>;
+}>;
 declare var DATATRANS_PAYMENT_METHODS: readonly string[];
 declare var DATATRANS_TEST_PANS: readonly string[];
 declare function encodeDatatransFormValue(value: any): string;
@@ -28,11 +34,20 @@ declare function classifyDatatransRequest(url: any, method: any, body: any, head
 declare function datatransTokenizeRefusal(request: any, card: any, policy?: string): "unsupported" | "card_on_file" | null;
 declare function isDatatransTokenizeRequest(request: any, card: any): boolean;
 declare function datatransMerchantRefusal(url: any, body: any, merchants?: Readonly<{
-    "pay.datatrans.com": readonly never[];
+    "pay.datatrans.com": readonly string[];
     "pay.sandbox.datatrans.com": readonly string[];
 }>): "unregistered_merchant" | null;
+declare function datatransMerchantAccountName(url: any, body: any, merchants?: Readonly<{
+    "pay.datatrans.com": readonly string[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>, names?: Readonly<{
+    "pay.datatrans.com": Readonly<{
+        "3000022877": "RaiseNow";
+    }>;
+    "pay.sandbox.datatrans.com": Readonly<{}>;
+}>): string | null;
 declare function datatransDeviceRefusal(request: any, card: any, policy?: string, merchants?: Readonly<{
-    "pay.datatrans.com": readonly never[];
+    "pay.datatrans.com": readonly string[];
     "pay.sandbox.datatrans.com": readonly string[];
 }>): "unsupported" | "card_on_file" | "brand_mismatch" | "unregistered_merchant" | null;
 declare function datatransRefusalMessage(reason: any): string;
@@ -61,4 +76,4 @@ declare function datatransFacts(status: any, body: any): {
     outcome: string;
     refusalCode: string | RegExp | null | undefined;
 };
-export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };
+export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_MERCHANT_ACCOUNT_NAMES, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantAccountName, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };

package/dist/datatrans.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: fdee611015d42dc0a679e93a64766ac971b190fcc8f17a107d761c414569e5f9
+// artifact-sha256: 9c00d227ed43d3b5346dba02fe0431f4cc4762fc7d2d9333eeeb34233b0c9844
 // src/datatrans.js
 var DATATRANS_HOSTS = Object.freeze(["pay.datatrans.com", "pay.sandbox.datatrans.com"]);
 var DATATRANS_TOKENIZE_PATH = "/upp/payment/SecureFields/paymentField";
@@ -10,9 +10,13 @@ var DATATRANS_CARD_ON_FILE_REFUSED = "datatrans_card_on_file_refused";
 var DATATRANS_REGISTRATION_POLICIES = Object.freeze(["refuse", "disclose", "agentcard_single_use"]);
 var DATATRANS_REGISTRATION_POLICY = "refuse";
 var DATATRANS_REVIEWED_MERCHANT_IDS = Object.freeze({
-    "pay.datatrans.com": Object.freeze([]),
+    "pay.datatrans.com": Object.freeze(["3000022877"]),
     "pay.sandbox.datatrans.com": Object.freeze(["1110022968", "1100007006"])
 });
+var DATATRANS_MERCHANT_ACCOUNT_NAMES = Object.freeze({
+    "pay.datatrans.com": Object.freeze({ "3000022877": "RaiseNow" }),
+    "pay.sandbox.datatrans.com": Object.freeze({})
+});
 var DATATRANS_PAYMENT_METHODS = Object.freeze(["VIS", "ECA", "AMX", "DIN", "DIS", "JCB", "CUP", "MAU", "UAP", "DNK"]);
 var DATATRANS_TEST_PANS = Object.freeze([
     "4242424242424242",
@@ -268,6 +272,14 @@ function datatransMerchantRefusal(url, body, merchants = DATATRANS_REVIEWED_MERC
     const listed = record(merchants) && owns(merchants, host) && Array.isArray(merchants[host]) ? merchants[host] : [];
     return merchantId !== null && listed.includes(merchantId) ? null : "unregistered_merchant";
 }
+function datatransMerchantAccountName(url, body, merchants = DATATRANS_REVIEWED_MERCHANT_IDS, names = DATATRANS_MERCHANT_ACCOUNT_NAMES) {
+    if (!isDatatransTokenizeUrl(url) || datatransMerchantRefusal(url, body, merchants) !== null)
+        return null;
+    const host = new URL(url).hostname, merchantId = datatransMerchantId(body);
+    const named = record(names) && owns(names, host) && record(names[host]) ? names[host] : null;
+    const name = named && owns(named, merchantId) ? named[merchantId] : null;
+    return typeof name === "string" && name.trim() !== "" && plain(name, 64) ? name : null;
+}
 function datatransDeviceRefusal(request, card, policy = DATATRANS_REGISTRATION_POLICY, merchants = DATATRANS_REVIEWED_MERCHANT_IDS) {
     const refusal = datatransTokenizeRefusal(request, card, policy);
     if (refusal)
@@ -426,4 +438,4 @@ function datatransFacts(status, body) {
     const verdict = datatransResponseOutcome(status, body);
     return { outcome: verdict.outcome, refusalCode: verdict.outcome === "refused" ? verdict.code : null };
 }
-export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };
+export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_MERCHANT_ACCOUNT_NAMES, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantAccountName, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };

package/dist/ebanx.d.ts

@@ -0,0 +1,107 @@
+export declare const EBANX_RESEND_REASON: "unsupported_ebanx_card_resend";
+/** Why the gate refuses a request (payment-core EBANX_RESEND_REFUSALS). */
+export type EbanxResendRefusal = 'three_ds_card' | 'confirm_card_code' | 'unreadable';
+/** The sends one approval covers, in EBANX.js's order (payment-core EBANX_FOLLOW_UP_KINDS). */
+export type EbanxFollowUpKind = 'generate_token' | 'authentications' | 'authentication_results' | 'confirm';
+/** EBANX's hosts for these requests (payment-core EBANX_RESEND_HOSTS). */
+export declare const EBANX_RESEND_HOSTS: readonly string[];
+/**
+ * CDP Fetch patterns for the 3-D Secure calls and the confirm on each of EBANX's hosts, armed on every attachment.
+ * The card recognizer already arms every request on the hosts it names; these keep both requests armed for a client
+ * whose registry names no EBANX host. The -record call matches the 3-D Secure pattern too and continues untouched.
+ * The third pattern arms any address on the host that holds a percent-escape, since CDP matches the address as written
+ * and a server may decode /ws/%63heckout-v2/confirm to the confirm: the gate decodes the path the same way
+ * (payment-core ebanxResendKind) and continues every one that is not a card send. CDP matches literally and in one
+ * letter case, so the tenant host only the confirm uses (CONFIRM_TENANT_HOST) is armed whole, its host text anywhere
+ * in the address as the card recognizer arms its own hosts: /WS/CHECKOUT-V2/CONFIRM, //, ;x=1 and a trailing-dot
+ * host all pause, and the gate judges each one.
+ */
+export declare const EBANX_RESEND_PATTERNS: readonly string[];
+/**
+ * Whether this URL is one of the three 3-D Secure calls that carry the card or the hosted page's confirm on an EBANX
+ * host, or an EBANX path still percent-encoded after the last decoding round, which the gate refuses as unreadable.
+ */
+export declare function isEbanxResendUrl(url: string): boolean;
+/**
+ * Why this request must not leave the browser with the card the page holds, or null when it may. The body is read
+ * only for a confirm, through `readBody`, and a reader that throws reads as a body nobody could read.
+ */
+export declare function ebanxResendRefusalOf(url: string, method: string, readBody: () => string | null): EbanxResendRefusal | null;
+/**
+ * A send the cardholder's device did not answer with EBANX's own answer. `reason` is the API's word for it:
+ * `not_picked_up` (no device started it in time: the Vault page was closed or asleep), `not_sent` (the device
+ * refused it before the card left), `no_answer`, `answer_withheld` (EBANX's answer carried the card),
+ * `answer_refused`, `answer_late`, `response_expired`, or the API's refusal code when it did not take the send at
+ * all (`follow_up_refused`, `follow_up_not_covered`, `follow_up_window_closed`). `cardSent` says whether the card
+ * may have reached EBANX: false only when the API confirmed it never left the device. Nothing in it names the
+ * request, the card or EBANX's answer.
+ */
+export declare class EbanxFollowUpError extends Error {
+    readonly reason: string;
+    readonly cardSent: boolean;
+    readonly authorizationId: string;
+    constructor(reason: string, cardSent: boolean, authorizationId: string);
+}
+/** A send this attachment claimed: the approval it goes under, its kind, the request to send, and how it ended. */
+export interface EbanxFollowUpClaim {
+    readonly authorizationId: string;
+    readonly kind: EbanxFollowUpKind;
+    readonly until: number;
+    readonly request: {
+        url: string;
+        method: 'POST';
+        headers: Record<string, string>;
+        body: string;
+    };
+    /** Record the answer the page received, or null when the send failed. */
+    settle(answer: {
+        status: number;
+        text: string;
+    } | null): void;
+}
+/**
+ * What one attachment keeps of its approved EBANX token request: the request and EBANX's answer as the page received
+ * them, until when the API said the approval covers sends after it, and the sends it claimed since, in order. Only
+ * a token approval whose read named that window (`followUpsUntil`, served for a company Agentcard turned it on for)
+ * is kept; a later approval replaces it, and a send the window has passed is never claimed. Once the gate refuses a
+ * send or a send fails, the attachment stops (stop()): nothing after it is claimed, a later approval included, so
+ * a page the controller already reads as stopped cannot finish 3-D Secure and pay through the confirm.
+ */
+export declare class EbanxFollowUps {
+    private parent;
+    private sent;
+    private stopped;
+    /** After a refused or failed send: no later request on this attachment is claimed. */
+    stop(): void;
+    /**
+     * The approval the remembered token request went under, or null when none is remembered. The gate sends nothing
+     * unless the checkout's own state names this same approval (pre-claim.ts ebanxMaySend).
+     */
+    get authorizationId(): string | null;
+    /**
+     * As the adapter hands an approved token request's answer to the page: before the answer lands, since the page may
+     * send its first 3-D Secure call at once. A handoff that fails then stops the attachment (stop()).
+     */
+    remember(request: {
+        url: string;
+        body: string;
+    }, replay: {
+        mode?: string;
+        authorizationId: string;
+        status: number;
+        body: string;
+        followUpsUntil?: string;
+    }): void;
+    /**
+     * The claim for a paused request the remembered approval covers, or null: no approval covers sends here, its
+     * window has passed, or payment-core's rule refuses the request against the sends already claimed (the amount
+     * is left to the API and the device, which hold the approved figure). Synchronous, and it reserves the send, so
+     * two requests can never both be claimed as the next one.
+     */
+    claim(request: {
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+        body: string | null;
+    }, now?: number): EbanxFollowUpClaim | null;
+}

package/dist/ebanx.generated.d.ts

@@ -0,0 +1,78 @@
+declare var EBANX_RESEND_HOSTS: readonly string[];
+declare var EBANX_THREE_DS_CARD_PATHS: readonly string[];
+declare var EBANX_CONFIRM_PATH: string;
+declare var EBANX_RESEND_REFUSALS: readonly string[];
+declare function ebanxResendKind(url: any): "unreadable" | "confirm" | "three_ds" | null;
+declare function ebanxResendRefusal(request: any): "unreadable" | "three_ds_card" | "confirm_card_code" | null;
+declare var EBANX_FOLLOW_UP_KINDS: readonly string[];
+declare var EBANX_FOLLOW_UP_LIMITS: Readonly<{
+    generate_token: 1;
+    authentications: 1;
+    authentication_results: 48;
+    confirm: 1;
+}>;
+declare var EBANX_FOLLOW_UP_MAX: number;
+declare var EBANX_FOLLOW_UP_WINDOW_MS: number;
+declare var EBANX_FOLLOW_UP_IDLE_MS: number;
+declare var EBANX_FOLLOW_UP_CHALLENGE_MS: number;
+declare var EBANX_FOLLOW_UP_BODY_LIMIT: number;
+declare var EBANX_FOLLOW_UP_ANSWER_LIMIT: number;
+declare var EBANX_FOLLOW_UP_REFUSALS: readonly string[];
+declare function ebanxFollowUpKind(url: any): "confirm" | "generate_token" | "authentications" | "authentication_results" | null;
+declare function readEbanxTokenRequest(template: any): Readonly<{
+    host: string;
+    number: string;
+    month: number;
+    year: number;
+    cvv: string | null;
+    name: string | null;
+    publicIntegrationKey: any;
+    country: any;
+}> | null;
+declare function readEbanxTokenAnswer(answer: any): Readonly<{
+    token: any;
+    paymentTypeCode: any;
+    cardUniqueId: any;
+}> | null;
+declare var EBANX_PAYING_STATUSES: readonly string[];
+declare function ebanxAnswerRefusal(status: any, answerText: any): string | null;
+declare var EBANX_THREE_DS_FAILED: string;
+declare var EBANX_THREE_DS_FAILED_CODE: string;
+declare function ebanxAnswerOutcome(status: any, answerText: any, url: any): {
+    outcome: string;
+    code: string;
+    reason?: undefined;
+} | {
+    outcome: string;
+    code?: undefined;
+    reason?: undefined;
+} | {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+} | null;
+declare function ebanxAnswerSession(answerText: any): Readonly<{
+    paymentId: any;
+    accessToken: any;
+    status: any;
+}>;
+declare function ebanxFollowUpIdleMs(kind: any, answerText: any): number;
+declare function ebanxFollowUpVerdict(input: any, options?: {}): Readonly<{
+    ok: false;
+    refusal: any;
+}> | Readonly<{
+    ok: true;
+    kind: "confirm";
+    slot: number;
+}> | Readonly<{
+    ok: true;
+    kind: "generate_token";
+    slot: number;
+}> | Readonly<{
+    ok: true;
+    kind: "authentications" | "authentication_results";
+    slot: number;
+}>;
+declare function ebanxFollowUpAnswerRefusal(answerText: any): "answer_unreadable" | "card_in_answer" | null;
+declare function isEbanxThreeDsFollowUp(kind: any): boolean;
+export { EBANX_CONFIRM_PATH, EBANX_FOLLOW_UP_ANSWER_LIMIT, EBANX_FOLLOW_UP_BODY_LIMIT, EBANX_FOLLOW_UP_CHALLENGE_MS, EBANX_FOLLOW_UP_IDLE_MS, EBANX_FOLLOW_UP_KINDS, EBANX_FOLLOW_UP_LIMITS, EBANX_FOLLOW_UP_MAX, EBANX_FOLLOW_UP_REFUSALS, EBANX_FOLLOW_UP_WINDOW_MS, EBANX_PAYING_STATUSES, EBANX_RESEND_HOSTS, EBANX_RESEND_REFUSALS, EBANX_THREE_DS_CARD_PATHS, EBANX_THREE_DS_FAILED, EBANX_THREE_DS_FAILED_CODE, ebanxAnswerOutcome, ebanxAnswerRefusal, ebanxAnswerSession, ebanxFollowUpAnswerRefusal, ebanxFollowUpIdleMs, ebanxFollowUpKind, ebanxFollowUpVerdict, ebanxResendKind, ebanxResendRefusal, isEbanxThreeDsFollowUp, readEbanxTokenAnswer, readEbanxTokenRequest };