@agent-cards/sdk 0.23.12 → 0.23.14

package/dist/cdp.js

@@ -8,13 +8,17 @@ 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 { 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';
@@ -338,8 +342,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
@@ -1532,7 +1542,10 @@ function replayOf(result, timeoutMs) {
         || !response.headers || typeof response.headers !== 'object' || Array.isArray(response.headers)) {
         throw new Error('An approved token read resumes with response, the processor\'s answer (voice.awaitResult carries it once the purchase finished).');
     }
-    return { mode: 'token', authorizationId, status: response.status, headers: { ...response.headers }, body: response.body, amountVerified: null, ...execution };
+    // The read's processor_context rides as it came: a Paddle VGS answer is handed to the page only with the
+    // approved card's details its /pay names (paddle-vgs-pay.ts checks them before the hand-over).
+    return { mode: 'token', authorizationId, status: response.status, headers: { ...response.headers }, body: response.body, amountVerified: null,
+        ...(result.processor_context !== undefined ? { processorContext: result.processor_context } : {}), ...execution };
 }
 /** The recogniser that claimed a paused request, by processor name, so a caller never re-matches the URL; null on a duck-typed vault without the read. */
 function recognizerNameOf(opts, url, method) {
@@ -1754,6 +1767,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).
@@ -2019,6 +2034,10 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // committing a new document (Page.frameNavigated, at the top of the event handler).
     const shijiCompanions = new ShijiStsCompanions();
     lifecycle.abort.signal.addEventListener('abort', () => shijiCompanions.release(), { once: true });
+    // Paddle's /pay after the stored card's id this attachment handed a frame (paddle-vgs-pay.ts): its
+    // checkout services are held only when the synced registry serves Paddle VGS, and a cancel drops the binding.
+    const paddleVgsPay = new PaddleVgsPayGate(() => recognizesPaddleVgs(opts.vault));
+    lifecycle.abort.signal.addEventListener('abort', () => paddleVgsPay.release(), { once: true });
     const derived = typeof opts.vault?.cardUrlPatterns === 'function' ? opts.vault.cardUrlPatterns() : [];
     // The endpoint and siblings of every merchant profile this build reviewed
     // (merchant-hosted.ts), which a VaultClient arms from the start: a profile's card
@@ -2042,11 +2061,15 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
     // 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).
     // 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])];
+            ...(payrails ? PAYRAILS_GUARD_PATTERNS : []), ...PAYPAL_HOSTED_FIELDS_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))
@@ -2476,10 +2499,12 @@ 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) },
             worldlineMyCheckout: worldlineProducts,
+            paddleVgsPay,
         });
         const preClaim = preClaimResult instanceof Promise ? await preClaimResult : preClaimResult;
         if (preClaim.kind !== 'pause')
@@ -2588,7 +2613,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);
@@ -2597,12 +2625,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;
@@ -2631,6 +2659,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).
@@ -2901,6 +2931,23 @@ export async function attachToCdp(cdp, pageSessionId, opts) {
                 // device_encrypt answer (Payrails' 201, which the device obtained) is
                 // handed over the same way.
                 const cors = corsDecision(deliverRequest.url, deliverRequest.headers);
+                // A Paddle card request's answer is the stored card's id: the frame's /pay that follows continues only
+                // with the approved card's details, bound to that frame before the id reaches it (paddle-vgs-pay.ts).
+                // An answer that came with no details is not handed over: its /pay could only name the placeholder.
+                try {
+                    paddleVgsPay.arm(activeRequest?.frameId || undefined, deliverRequest.url, replay);
+                }
+                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,
@@ -2926,6 +2973,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))
@@ -3070,6 +3121,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);
@@ -3131,6 +3184,9 @@ export async function attachToPlaywright(page, opts) {
     // a new document (the handlers below).
     const shijiCompanions = new ShijiStsCompanions();
     lifecycle.abort.signal.addEventListener('abort', () => shijiCompanions.release(), { once: true });
+    // Paddle's /pay after the stored card's id this attachment handed a frame, as attachToCdp binds it.
+    const paddleVgsPay = new PaddleVgsPayGate(() => recognizesPaddleVgs(opts.vault));
+    lifecycle.abort.signal.addEventListener('abort', () => paddleVgsPay.release(), { once: true });
     // An answer to a request the facts watch records began to arrive: the watch orders what the page sent after a
     // record by this moment, since Playwright reports the answer's end after the page's next request. Listened to only
     // once the page sent such a request, so a page that never meets a merchant with facts carries no extra listener.
@@ -3385,10 +3441,21 @@ 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())
             // CyberSource Secure Acceptance's /silent/ paths, for every org, as attachToCdp arms them (cybersource-secure-acceptance.ts).
-            || isCybersourceSecureAcceptanceUrl(url.toString()), async (route) => {
+            || 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))
+            // 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();
@@ -3481,10 +3548,12 @@ 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}` },
                 worldlineMyCheckout: worldlineProducts,
+                paddleVgsPay,
             });
             const preClaim = preClaimResult instanceof Promise ? await preClaimResult : preClaimResult;
             if (preClaim.kind !== 'pause')
@@ -3574,7 +3643,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;
@@ -3587,12 +3658,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;
@@ -3640,6 +3711,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 {
@@ -3847,6 +3920,18 @@ export async function attachToPlaywright(page, opts) {
                     // none; written here anyway (replacing a stale value) so a
                     // cross-origin answer is the same whichever adapter ran.
                     const cors = corsDecision(deliverRequest.url(), deliverRequest.headers());
+                    // See the same step in attachToCdp: a Paddle stored card's id reaches its frame only with its /pay bound.
+                    try {
+                        paddleVgsPay.arm(frameOf(deliverRequest), deliverRequest.url(), replay);
+                    }
+                    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();
@@ -3862,6 +3947,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,29 @@ 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.
  */
 export declare const SUPPORTED_CAPABILITIES: readonly string[];
 /**
@@ -251,7 +280,10 @@ export interface ExecutionMetadata {
  * this is the processor's answer to replay into the paused request.
  */
 export interface TokenReplay extends ExecutionMetadata {
-    /** Authenticated selected-card metadata; the processor response body stays unchanged. */
+    /**
+     * Authenticated selected-card metadata; the processor response body stays unchanged. Paddle VGS: the
+     * approved card's first six and last four digits, expiry and brand, which the frame's /pay names.
+     */
     processorContext?: unknown;
     /** Present only after validating the native TEST Checkout completion. */
     checkoutSessionId?: string;
@@ -286,6 +318,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
@@ -313,6 +351,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;
 }
 /**
@@ -485,7 +530,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;
     /**
@@ -1042,6 +1092,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;
@@ -1101,6 +1159,11 @@ 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}`.
  * A string that is not a URL keeps the part before any `?` or `#`, with the
  * same segments masked.
  */
@@ -1457,6 +1520,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