@agent-cards/sdk 0.23.13 → 0.23.15

package/dist/cdp.js

@@ -8,14 +8,18 @@ import { MERCADO_CHECKOUT_PATTERN } from './mercado-checkout.generated.js';
 import { JuspayCheckoutGate } from './juspay-gate.js';
 import { ACI_CHECKOUT_REUSED, AciGate, playwrightReplacesNavigationBody } from './aci.js';
 import { EprotectGate } from './eprotect.js';
-import { dispatchPreClaim, eventUrl } from './pre-claim.js';
+import { dispatchPreClaim, eventUrl, isArmedCreditguardCall } from './pre-claim.js';
 import { GMO_TOKEN_V1_PATTERNS, gmoRequestShop, isGmoTokenV1Request, recognizesGmo } from './gmo.js';
 import { isPaddleVgsCardsUrl } from './paddle-vgs.generated.js';
 import { PADDLE_VGS_PAY_PATTERNS, PaddleVgsPayGate, isPaddleCheckoutService, recognizesPaddleVgs } from './paddle-vgs-pay.js';
 import { DatatransRepeats } from './datatrans.js';
 import { SHIJI_STS_COMPANION_WINDOW_MS, ShijiStsCompanions, ShijiStsError, isShijiStsHost, shijiStsTokenContinuation, } from './shiji-sts.js';
+import { paddleTokenexTokenContinuation } from './paddle-tokenex.js';
 import { isArmedEkashuUrl } from './ekashu.js';
+import { isArmedRedsysUrl } from './redsys.js';
 import { PAYPAL_HOSTED_FIELDS_PATTERNS, isPaypalHostedFieldsConfirm } from './paypal-hosted-fields.js';
+import { EBANX_RESEND_PATTERNS, EbanxFollowUps, isEbanxResendUrl } from './ebanx.js';
+import { PAYPAL_CARD_FORM_PATTERNS, isPaypalCardFormUrl } from './paypal-card-forms.js';
 import { CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, SecureAcceptanceFollowUpWatch, isCybersourceSecureAcceptanceUrl, secureAcceptanceFollowUp, secureAcceptanceFrameAnswer, secureAcceptanceReplyLast4, } from './cybersource-secure-acceptance.js';
 import { CheckoutAttachmentError, attachmentDeadline, attachmentFailure, withinAttachmentDeadline } from './attachment.js';
 import { cseBody } from './cse-body.js';
@@ -339,8 +343,14 @@ function cseAuthorizedDetail(replay, url, shijiCvv = null) {
  */
 function cseContinuation(opts, url, body, replay, approved, preparation) {
     const shiji = shijiStsTokenContinuation(url, body, replay.substitutions, approved, replay.kind === 'merchant_hosted' || replay.kind === 'verifone' ? undefined : replay.shijiStsCompanion);
-    return shiji ? { body: shiji.body, shijiCvv: shiji.cvv, shijiCvvKeySequenceSha256: shiji.cvvKeySequenceSha256 }
-        : { body: cseContinuationBody(opts, body, replay, url, preparation), shijiCvv: null, shijiCvvKeySequenceSha256: null };
+    if (shiji)
+        return { body: shiji.body, shijiCvv: shiji.cvv, shijiCvvKeySequenceSha256: shiji.cvvKeySequenceSha256 };
+    // Paddle TokenEx writes two ciphertexts and five metadata facts under the pinned key, which the generic
+    // Adyen swap cannot, so it is dispatched by the /pay URL to substitutePaddleTokenex (paddle-tokenex.ts).
+    const paddleTokenex = replay.kind === undefined ? paddleTokenexTokenContinuation(url, body, replay.substitutions, replay.paddleTokenexFacts, approved) : null;
+    if (paddleTokenex)
+        return { body: paddleTokenex.body, shijiCvv: null, shijiCvvKeySequenceSha256: null };
+    return { body: cseContinuationBody(opts, body, replay, url, preparation), shijiCvv: null, shijiCvvKeySequenceSha256: null };
 }
 /**
  * The opaque page id a Shiji STS companion is bound to: the CDP session and
@@ -1373,11 +1383,12 @@ function merchantAttempt(lifecycle, survives) {
     let rebound = false;
     let delivering = false;
     let bound = null;
-    // A send window (an Amadeus SDK add's, a Secure Acceptance token create's) closes only once the API
-    // confirms the card never left the device and never can (amadeus.ts): a known non-payment, so the
-    // prepared checkout ends failed with that reason, and a fresh attachment can prepare again. Every
-    // other stop leaves the outcome unknown.
+    // A send window (an Amadeus SDK add's, a Secure Acceptance token create's, a Wix tokenize request's)
+    // closes only once the API confirms the card never left the device and never can (amadeus.ts): a
+    // known non-payment, so the prepared checkout ends failed with that reason, and a fresh attachment can
+    // prepare again. Every other stop leaves the outcome unknown.
     const error = () => reason === 'amadeus_send_window_closed' || reason === 'secure_acceptance_send_window_closed'
+        || reason === 'wix_payments_send_window_closed'
         ? new CheckoutPreparationError(lifecycle.getState().preparationId ?? null, reason)
         : new PaymentOutcomeUnknownError(lifecycle.getState().authorizationId, reason);
     const attempt = {
@@ -1607,8 +1618,8 @@ function pauseForBusiness(opts, lifecycle, attemptSignal, request, pageOrigin) {
 }
 /**
  * Arm the send window of a request paused under a preparation, when its processor sets one: a
- * prepared Amadeus SDK add and a prepared Secure Acceptance token create do (amadeus.ts
- * preparedSendWindowMs). Returns the disarm function, or null with no window. lifecycle.begin()
+ * prepared Amadeus SDK add, a prepared Secure Acceptance token create and a prepared Wix tokenize
+ * request do (amadeus.ts preparedSendWindowMs). Returns the disarm function, or null with no window. lifecycle.begin()
  * cleared the authorization ID, so the one the window reads is this attempt's.
  */
 function armWindowFor(opts, lifecycle, attempt, preparation, url, delivering) {
@@ -1758,6 +1769,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     };
     // Juspay's tokenize answer and the synthetic tokens it issued (juspay-gate.ts).
     const juspayCheckout = new JuspayCheckoutGate(opts.vault);
+    // The approved EBANX token request on this attachment and the sends claimed under it (ebanx.ts).
+    const ebanxFollowUps = new EbanxFollowUps();
     const aci = new AciGate(opts.vault);
     const eprotect = new EprotectGate(opts.vault);
     // The merchant's follow-up request after a delivered Secure Acceptance reply (cybersource-secure-acceptance.ts).
@@ -2049,13 +2062,20 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // PayPal's legacy Hosted Fields confirm is armed for every org, whatever the
     // registry serves: one that carries the typed card is paused only to be
     // refused, and one with no card continues (see paypal-hosted-fields.ts).
+    // PayPal's Card Fields confirm and GraphQL on www.paypal.com are armed the
+    // same way: a card the guard refuses is paused only to be refused, a
+    // confirm the registry recognizes pauses for its recognizer, and a request
+    // with no card continues (see paypal-card-forms.ts).
     // CyberSource Secure Acceptance's /silent/ paths are armed the same way, form
-    // navigations included (see cybersource-secure-acceptance.ts).
+    // navigations included (see cybersource-secure-acceptance.ts), and so are
+    // EBANX's 3-D Secure calls and hosted confirm, which send the typed card again
+    // after its token: the cardholder's device sends one the approved token request
+    // covers, and any other is refused (see ebanx.ts).
     const urlPatterns = [...new Set([...(derived.length > 0 ? derived : FALLBACK_CARD_PATTERNS), ...guards.patterns,
             ...(stripeCheckout.isEnabled() ? ['https://api.stripe.com/*'] : []), MERCADO_CHECKOUT_PATTERN, ...merchantPatterns,
             ...(recognizesGmo(opts.vault) ? GMO_TOKEN_V1_PATTERNS : []), ...juspayCheckout.urlPatterns(), ...cardEndpointPatterns(),
-            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS,
-            ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : [])])];
+            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_PATTERNS, ...PAYPAL_CARD_FORM_PATTERNS,
+            ...CYBERSOURCE_SECURE_ACCEPTANCE_PATTERNS, ...(recognizesPaddleVgs(opts.vault) ? PADDLE_VGS_PAY_PATTERNS : []), ...EBANX_RESEND_PATTERNS])];
     const arm = async (sessionId, resume = false, worker = false) => {
         const key = sessionId ?? '__root__';
         if (armed.has(key))
@@ -2485,6 +2505,7 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
             cybersourceFlex: { judge: (flexRequest) => microforms.judge(flexRequest, frameId, () => rereadMicroforms(sessionId, frameId)) },
             juspay: juspayCheckout,
             datatrans: datatransRepeats,
+            ebanx: ebanxFollowUps,
             frame: typeof frameId === 'string' && frameId ? frameId : undefined,
             payrails,
             shijiSts: { companions: shijiCompanions, page: () => cdpShijiPage(sessionId, frameId) },
@@ -2598,7 +2619,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         // A request that skipped the spent preparation's claim and was not bound as
         // its retry (the approval ended while it was judged) is refused as that
         // claim would refuse it, never asked as a new approval.
-        if (terminal || lifecycle.isBlocked() || awaitingApproval || preparedRetry || Date.now() < quietUntil) {
+        // An EBANX send still out (a confirm that may pay) holds the attachment too: a new card request the page sends
+        // meanwhile, a second tap on the hosted page's Pay among them, would start another payment over it.
+        const followUpOut = lifecycle.followUpsInFlight();
+        if (terminal || lifecycle.isBlocked() || awaitingApproval || followUpOut || preparedRetry || Date.now() < quietUntil) {
             let repeatedAuthorizationId = null;
             if (lastSubmitted) {
                 const body = pausedBody(request);
@@ -2607,12 +2631,12 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 }
             }
             const why = terminal ?? (lifecycle.isBlocked() ? lifecycle.getState().status : awaitingApproval ? 'an approval is already outstanding'
-                : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
+                : followUpOut ? 'an EBANX send is in flight' : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
             opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
             if (preparation)
                 preparationGate.retireUnboundClaim();
             // A card form navigation never reads that nothing was sent while a payment for this checkout may exist.
-            await refusePaused(requestId, sessionId, request.url, cardEndpoint, heldNavigationRefusal(terminal, awaitingApproval, lifecycle), secureAcceptance);
+            await refusePaused(requestId, sessionId, request.url, cardEndpoint, heldNavigationRefusal(terminal, awaitingApproval || followUpOut, lifecycle), secureAcceptance);
             if (repeatedAuthorizationId)
                 void opts.vault.reportDuplicateGuard?.(repeatedAuthorizationId);
             return;
@@ -2641,6 +2665,8 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         // The approval the device gave, and whether it reached a browser request.
         let approvedId = null;
         let deliveryBegun = false;
+        // Whether this handoff kept an EBANX approval's follow-ups (ebanxFollowUps.remember), which a failed handoff stops.
+        let ebanxRemembered = false;
         // The business's pause, so resume resolves once the page has its answer.
         let businessPause = null;
         // A prepared Amadeus SDK add must be sent within its window (see amadeus.ts).
@@ -2920,6 +2946,14 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 catch {
                     throw new PaymentOutcomeUnknownError(replay.authorizationId, 'paddle_vgs_card_facts_unavailable');
                 }
+                // An approved EBANX token request whose read names a window covers the 3-D Secure calls and the confirm the
+                // page sends next (ebanx.ts): kept as the API stored it, the request that raised the approval. Kept before the
+                // page has the answer, since the page may send its first 3-D Secure call the moment the answer lands; a
+                // handoff that then fails stops them (the catch below).
+                if (replay.mode !== 'device_encrypt') {
+                    ebanxFollowUps.remember({ url: request.url, body }, replay);
+                    ebanxRemembered = true;
+                }
                 await cdp.send('Fetch.fulfillRequest', {
                     requestId: deliverTo,
                     responseCode: replay.status,
@@ -2945,6 +2979,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
         catch (err) {
             // Ignore the failure event caused by our own safe decline/error abort.
             const dead = attempt.target ?? { requestId, sessionId };
+            // An EBANX token answer this handoff kept follow-ups for and did not finish handing over: nothing after it is
+            // claimed (ebanx.ts EbanxFollowUps.stop).
+            if (ebanxRemembered)
+                ebanxFollowUps.stop();
             // The business's resume settles once the request is answered: a terminal read is an answer (failed, nothing charged), a lost handoff is not.
             const settlePause = () => { if (businessPause) {
                 if (isApprovalOutcome(err))
@@ -3089,6 +3127,8 @@ export async function attachToPlaywright(page, opts) {
     };
     // Juspay's tokenize answer and the synthetic tokens it issued (juspay-gate.ts).
     const juspayCheckout = new JuspayCheckoutGate(opts.vault);
+    // The approved EBANX token request on this attachment and the sends claimed under it (ebanx.ts).
+    const ebanxFollowUps = new EbanxFollowUps();
     const aci = new AciGate(opts.vault);
     let navigationBodyReplaced;
     const eprotect = new EprotectGate(opts.vault);
@@ -3407,12 +3447,23 @@ export async function attachToPlaywright(page, opts) {
             // Every request to an NMI host whose entry is served (ekashu.ts), as attachToCdp arms the
             // host: the card page's post and its 3-D Secure calls reach the NMI gate and fail.
             || isArmedEkashuUrl(opts.vault, url.toString())
+            // A CreditGuard page's own calls beside its submit (its card lookup and its 3-D Secure calls), for an
+            // org the API served CreditGuard to, as attachToCdp arms its hosts: the CreditGuard gate answers them
+            // under a ready preparation and lets them go on with none (pre-claim.ts isArmedCreditguardCall).
+            || isArmedCreditguardCall(opts.vault, url.toString())
+            // Every request to a Redsys host once its entry is served (redsys.ts), as attachToCdp arms the
+            // hosts: the card page's post and Redsys's other card requests reach the Redsys gate and fail.
+            || isArmedRedsysUrl(opts.vault, url.toString())
             // PayPal's legacy Hosted Fields confirm, for every org, as attachToCdp arms it (paypal-hosted-fields.ts).
             || isPaypalHostedFieldsConfirm(url.toString())
+            // PayPal's Card Fields confirm and GraphQL on www.paypal.com, for every org, as attachToCdp arms them (paypal-card-forms.ts).
+            || isPaypalCardFormUrl(url.toString())
             // CyberSource Secure Acceptance's /silent/ paths, for every org, as attachToCdp arms them (cybersource-secure-acceptance.ts).
             || isCybersourceSecureAcceptanceUrl(url.toString())
             // Paddle's checkout services, routed only for an org the API served Paddle VGS to (see attachToCdp).
-            || (isPaddleCheckoutService(url.toString()) && recognizesPaddleVgs(opts.vault)), async (route) => {
+            || (isPaddleCheckoutService(url.toString()) && recognizesPaddleVgs(opts.vault))
+            // EBANX's 3-D Secure calls and hosted confirm, for every org, as attachToCdp arms them (ebanx.ts).
+            || isEbanxResendUrl(url.toString()), async (route) => {
             const request = route.request();
             // When this request paused, and the page it came from: the merchant's total is read as of now.
             const pausedAt = Date.now();
@@ -3505,6 +3556,7 @@ export async function attachToPlaywright(page, opts) {
                     } },
                 juspay: juspayCheckout,
                 datatrans: datatransRepeats,
+                ebanx: ebanxFollowUps,
                 frame: frameOf(request),
                 payrails,
                 shijiSts: { companions: shijiCompanions, page: async () => (await playwrightShijiDocumentPage(request)) ?? `pw:none:${++playwrightShijiSeq}` },
@@ -3599,7 +3651,9 @@ export async function attachToPlaywright(page, opts) {
             // identically whichever adapter is attached. An Amadeus card request is
             // 'failed' (ERR_FAILED) in both too, see failsAsNetworkError (refusalFailure).
             // As in attachToCdp: an unbound request that skipped the spent preparation's claim is refused.
-            if (terminal || lifecycle.isBlocked() || awaitingApproval || preparedRetry || Date.now() < quietUntil) {
+            // As in attachToCdp: an EBANX send still out holds the attachment too.
+            const followUpOut = lifecycle.followUpsInFlight();
+            if (terminal || lifecycle.isBlocked() || awaitingApproval || followUpOut || preparedRetry || Date.now() < quietUntil) {
                 let repeatedAuthorizationId = null;
                 if (lastSubmitted) {
                     let body = null;
@@ -3612,12 +3666,12 @@ export async function attachToPlaywright(page, opts) {
                     }
                 }
                 const why = terminal ?? (lifecycle.isBlocked() ? lifecycle.getState().status : awaitingApproval ? 'an approval is already outstanding'
-                    : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
+                    : followUpOut ? 'an EBANX send is in flight' : preparedRetry ? 'CheckoutPreparationError' : 'awaiting approval cooldown');
                 opts.onEvent?.({ type: 'blocked', detail: why instanceof Error ? failureSummary(why) : String(why) });
                 if (preparation)
                     preparationGate.retireUnboundClaim();
                 // As in attachToCdp: never that nothing was sent while a payment for this checkout may exist.
-                const refused = await refuseRoute(route, heldNavigationRefusal(terminal, awaitingApproval, lifecycle));
+                const refused = await refuseRoute(route, heldNavigationRefusal(terminal, awaitingApproval || followUpOut, lifecycle));
                 if (repeatedAuthorizationId)
                     void opts.vault.reportDuplicateGuard?.(repeatedAuthorizationId);
                 return refused;
@@ -3665,6 +3719,8 @@ export async function attachToPlaywright(page, opts) {
             // The approval the device gave, and whether it reached a browser request.
             let approvedId = null;
             let deliveryBegun = false;
+            // See the same flag in attachToCdp.
+            let ebanxRemembered = false;
             // A prepared Amadeus SDK add must be sent within its window (see amadeus.ts).
             let disarmSendWindow = null;
             try {
@@ -3879,6 +3935,11 @@ export async function attachToPlaywright(page, opts) {
                     catch {
                         throw new PaymentOutcomeUnknownError(replay.authorizationId, 'paddle_vgs_card_facts_unavailable');
                     }
+                    // See the same step in attachToCdp: kept before the page has the answer.
+                    if (replay.mode !== 'device_encrypt') {
+                        ebanxFollowUps.remember({ url: request.url(), body }, replay);
+                        ebanxRemembered = true;
+                    }
                     await deliverTo.fulfill({ status: replay.status, headers: withCorsHeaders(replay.headers, cors.headers), body: replay.body });
                     datatransRepeats.remember(frameOf(deliverRequest), deliverRequest.url(), deliverBody, replay);
                     assertRequestLive();
@@ -3894,6 +3955,9 @@ export async function attachToPlaywright(page, opts) {
             }
             catch (err) {
                 const dead = attempt.target?.route ?? route;
+                // See the same step in attachToCdp.
+                if (ebanxRemembered)
+                    ebanxFollowUps.stop();
                 if (activeRequest?.attempt === attempt)
                     activeRequest = null;
                 try {

package/dist/client.d.ts

@@ -5,6 +5,7 @@ import { type MerchantTotalApproved, type MerchantTotalCapture } from './merchan
 import { type PreparationMode, type PreparationProcessor } from './prepared-processor.js';
 import { type VerifoneProfile, type VerifoneSubstitutions } from './verifone.js';
 import { type MerchantSessionCapture } from './merchant-session-probe.js';
+import { type PaddleTokenexServedFacts } from './paddle-tokenex.js';
 import { VoiceModule, type VoiceOptions } from './voice.js';
 import { BuyModule } from './buy.js';
 import { RequestRegistry } from './requests.js';
@@ -205,6 +206,11 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * Moneris on for. A gated recognizer never sits in BUILTIN_REGISTRY, so it is paused
  * only after a sync.
  *
+ * `redsys_hosted_payment_page`: Redsys's hosted payment page (the TPV Virtual redirect), whose
+ * card-free signed entry this build pauses for the cardholder's device and whose card page this build
+ * never lets the agent's browser post to (pre-claim.ts, redsys.ts). Served on the same terms as NMI's: only
+ * to a build that lists it, for a company Agentcard turned Redsys on for.
+ *
  * `paddle_vgs_cards`: the card request Paddle's checkout frame sends to its VGS card
  * vault (vault.paddle.com/cards) on a checkout that names VGS, only through a prepared
  * checkout: the frame aborts the request 10 seconds after Pay and sends it once more,
@@ -212,6 +218,37 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * device sends the card itself and the frame gets back the stored card's id alone.
  * Served on the same terms: only to a build that lists it, for a company Agentcard
  * turned Paddle on for.
+ *
+ * `paddle_tokenex_pay`: the /pay Paddle's checkout frame sends to its checkout service
+ * (checkout-service.paddle.com) on a checkout that names TokenEx. The frame encrypts the
+ * card in the page under the account's TokenEx key, so /pay carries the placeholder's two
+ * ciphertexts and facts; this build pauses it and writes over them the device's own, under
+ * the key payment-core pins (paddle-tokenex.ts). Served on the same terms: only to a build
+ * that lists it, for a company Agentcard turned Paddle on for.
+ *
+ * `lyra_krypton_payment`: the card payment Lyra's Krypton form (PayZen, Systempay,
+ * Sogecommerce) sends from its hidden checkout frame to ProcessPayment/2 on the brand's API
+ * host. This build pauses only the frame's card body under a form token that pays once; the
+ * cardholder's device sends the card through the checkout relay, and the frame gets Lyra's
+ * answer byte for byte with Lyra's payment id, so it runs any 3-D Secure step itself and its
+ * card-free follow-up passes untouched. Served on the same terms: only to a build that lists
+ * it, for a company Agentcard turned Lyra on for.
+ *
+ * `payfast_card_pay`: the card tab's pay on Payfast's hosted payment page (POST
+ * /eng/method/CreditCard/<uuid>/pay on payment.payfast.io, www.payfast.co.za or the sandbox),
+ * which this build pauses only as the card tab's own form body and answers with Payfast's own
+ * answer as the API recorded it: `[true]` once the payment is done, or the 3-D Secure step the
+ * card tab then runs in the agent's browser. The cardholder's device sends the card through the
+ * checkout relay. Served on the same terms: only to a build that lists it, for a company
+ * Agentcard turned Payfast on for.
+ *
+ * `wix_payments_tokenize`: the card request Wix Cashier's card frame sends to Wix's
+ * tokenizer (cashier-pci.wixapps.net), only through a prepared checkout: Wix's payment
+ * widget fails the payment 30 seconds after it asks the frame for a token. The
+ * cardholder's device sends the card through the checkout relay and the frame gets back
+ * Wix's token. A second card request from the frame, which Wix's frame sends after a 401
+ * or 403 under a fresh instance, is never answered from the same approval. Served on the
+ * same terms: only to a build that lists it, for a company Agentcard turned Wix on for.
  */
 export declare const SUPPORTED_CAPABILITIES: readonly string[];
 /**
@@ -289,6 +326,12 @@ export interface TokenReplay extends ExecutionMetadata {
     chargedKind?: 'captured' | 'authorized' | 'none' | null;
     /** Who named the amount the person approved. */
     amountAuthority?: AmountAuthority;
+    /**
+     * An EBANX token approval that covers the sends EBANX's page makes after it (its 3-D Secure calls and the hosted
+     * page's confirm), for a company Agentcard turned that on for: until when (ISO 8601) the adapters may ask the
+     * cardholder's device to send them (sendEbanxFollowUp). Absent on every other approval.
+     */
+    followUpsUntil?: string;
 }
 /**
  * The cse flow (Adyen): the cardholder's device encrypted the card under the
@@ -316,6 +359,13 @@ export interface CseReplay extends ExecutionMetadata {
     shijiStsCompanion?: Readonly<{
         keySequenceSha256: readonly string[];
     }>;
+    /**
+     * Paddle TokenEx only: the five metadata facts the device read from the real card, served beside the two
+     * ciphertexts in `substitutions.fields` (`paddle_tokenex_facts`). The adapters write them over the
+     * placeholder's at metadata while the ciphertexts go into tokenex_card (paddle-tokenex.ts), because the
+     * expiry parts are numbers and cannot ride the string-only `fields`.
+     */
+    paddleTokenexFacts?: Readonly<PaddleTokenexServedFacts>;
     amountAuthority?: AmountAuthority;
 }
 /**
@@ -488,7 +538,12 @@ export interface PrepareCheckoutOptions {
      * it to the merchant (https://pps.creditguard.co.il/?txId=<transaction id>;
      * pps2 is production too, ppsuat is the sandbox). Agentcard reads that
      * transaction from CreditGuard before the cardholder is asked, and only that
-     * transaction's card submit can use the preparation.
+     * transaction's card submit can use the preparation. On a transaction that runs
+     * 3-D Secure through Cardinal, this SDK answers the page's own 3-D Secure calls
+     * and card lookup itself, so the placeholder never reaches CreditGuard, and the
+     * cardholder's device runs 3-D Secure with the real card before it sends the
+     * submit: prepare() tells Agentcard so (`three_d_secure: 'device'`), and
+     * Agentcard admits such a transaction only for a build that says it.
      */
     paymentPageUrl?: string;
     /**
@@ -1045,6 +1100,14 @@ export interface PresetRefusal {
 }
 /** A decline reason only the company presets stamp (see PresetRefusedError). */
 export declare const PRESET_REFUSAL_REASONS: ReadonlySet<string>;
+/**
+ * How often sendEbanxFollowUp reads a send back while the cardholder's device has it: every half second, whatever the
+ * client's own `pollIntervalMs`. One send is out at a time per approval, so this is 120 reads a minute, inside the
+ * API's 240 a minute per caller and authorization (routes/api/v2/checkout-follow-ups.ts).
+ */
+export declare const EBANX_FOLLOW_UP_READ_MS = 500;
+/** The longest sendEbanxFollowUp waits after reads the API refused as too many (429): 1, 2, 4, 8, then 15 seconds. */
+export declare const EBANX_FOLLOW_UP_BACKOFF_MAX_MS = 15000;
 export declare class CheckoutApiError extends Error {
     status: number;
     path: string;
@@ -1104,6 +1167,13 @@ export declare class CheckoutAuthError extends Error {
  * On Rapyd's hosts the hosted page's id reads `{token}`: https://api.rapyd.net/v1/checkout/{token}.
  * On api.stripe.com a Checkout Session id reads `{session}`:
  * https://api.stripe.com/v1/payment_pages/{session}/confirm.
+ * On Payfast's hosts the payment's uuid reads `{uuid}`:
+ * https://payment.payfast.io/eng/method/CreditCard/{uuid}/pay.
+ * On Redsys's hosts the session id after `;jsessionid=` reads `{session}`:
+ * https://sis.redsys.es/sis/pagoTarjeta;jsessionid={session}.
+ * On Lyra's API hosts the form token's session id reads `{session}`.
+ * On PayPal's hosts an order id reads `{order}`:
+ * https://www.paypal.com/v2/checkout/orders/{order}/confirm-payment-source.
  * A string that is not a URL keeps the part before any `?` or `#`, with the
  * same segments masked.
  */
@@ -1460,6 +1530,32 @@ export declare class VaultClient {
     }): Promise<{
         setupIntentId: string;
     }>;
+    /**
+     * Send one request an approved EBANX token request covers (ebanx.ts says which: EBANX's 3-D Secure calls and the
+     * hosted page's confirm, bound to that approval) from the cardholder's device, and resolve with EBANX's answer for
+     * the paused request: POST /v2/checkout/authorizations/:id/follow_ups with the request as the page sent it, the
+     * agent's placeholder card in it, then the send read back every half second until the device answered
+     * (EBANX_FOLLOW_UP_READ_MS, whatever `pollIntervalMs` says, so the reads stay inside the API's per-approval budget).
+     * A read the API refuses as too many (429) waits longer each time, doubling from a second up to
+     * EBANX_FOLLOW_UP_BACKOFF_MAX_MS, inside the same deadline, and the next answered read goes back to the half second.
+     * No prompt: the cardholder approved the token request, and the Vault page that sent it sends these while it stays
+     * open. Rejects with an EbanxFollowUpError naming why there is no answer and whether the card may have reached
+     * EBANX: the API refused the send (nothing sent), no device started it in time, the device refused it or withheld
+     * an answer that carried the card, or `options.until` (the approval's window, plus the API's own clocks) passed.
+     */
+    sendEbanxFollowUp(authorizationId: string, request: {
+        url: string;
+        method: 'POST';
+        headers: Record<string, string>;
+        body: string;
+    }, options?: {
+        signal?: AbortSignal;
+        until?: number;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    }>;
     /**
      * Create a merchant-session probe, the phase-0 read of the deterministic merchant total:
      * `user` is the org's connected user, who opens the returned Vault link and reads the