@agent-cards/sdk 0.23.13 → 0.23.15

package/dist/paddle-tokenex.js

@@ -0,0 +1,95 @@
+// Paddle TokenEx, the card leg of a Paddle checkout whose frame names the tokenization provider "tokenex",
+// as the SDK sees it (payment-core paddle-tokenex.js has the request's shape, the device encryption and the
+// substitution). Paddle's frame RSA-encrypts the card number and the CVV in the page itself, each on its
+// own, under the account-level TokenEx public key the checkout serves, and carries both inside one request:
+//   POST https://checkout-service.paddle.com/checkout/<id>/pay            (Paddle Classic)
+//   POST https://checkout-service.paddle.com/transaction-checkout/<id>/pay (Paddle Billing)
+// (sandbox-checkout-service.paddle.com in test). The agent's page encrypts a placeholder card, so the /pay
+// names the placeholder's ciphertexts and the placeholder's first six, last four, expiry and brand. This
+// build holds that /pay and writes over them the approved card's own: the two ciphertexts the cardholder's
+// device produced under the key payment-core pins (never a key from a row, a request or a page) and the
+// five metadata facts the device read from the real card. Every other byte goes as the frame wrote it
+// (mode cse), so the full card number never reaches the agent's runtime.
+//
+// The generic Adyen swap writes only the named ciphertext path, not the five metadata facts a sibling of
+// tokenex_card, so this lane is dispatched by psp to substitutePaddleTokenex instead, exactly as Shiji STS
+// is dispatched for its own body root. A production checkout-service refuses the Vault's cross-origin /pay
+// (403 at Cloudflare), so the device cannot send /pay itself and the lane rides in the agent's page.
+//
+// The registry entry ships dark (capability paddle_tokenex_pay). This build declares the capability on
+// syncRegistry, and the API serves the recognizer only to an org Agentcard enabled for paddle_tokenex, so
+// for every other org nothing here fires: isCardRequest never recognizes a TokenEx /pay and Paddle's
+// requests go through untouched. Autopilot never pays this processor: the API, the authority and the
+// enclave refuse it.
+import { PADDLE_TOKENEX_FIELDS, PADDLE_TOKENEX_FACT_KEYS, paddleTokenexPayTarget, substitutePaddleTokenex } from './paddle-tokenex.generated.js';
+/** The PSP id the API and the recognizer name this lane, re-exported so the client dispatches by it. */
+export { PADDLE_TOKENEX_PSP } from './paddle-tokenex.generated.js';
+/** The dark-launch capability a build declares when it fills a Paddle TokenEx /pay with the device's card. */
+export const PADDLE_TOKENEX_CAPABILITY = 'paddle_tokenex_pay';
+/** The holder the two ciphertexts are served at (the frame's tokenex_card), named once so both checks share it. */
+const SERVED_AT = 'data.payment_method_data.card.tokenex_card';
+const CIPHERTEXT_FIELDS = PADDLE_TOKENEX_FIELDS;
+const FACT_KEYS = PADDLE_TOKENEX_FACT_KEYS;
+const STRING_FACTS = ['card_first_six', 'card_last_four', 'card_brand'];
+const NUMBER_FACTS = ['expiry_month', 'expiry_year'];
+/**
+ * Whether an approved Paddle TokenEx authorization's served substitution is one this SDK can continue: JSON
+ * at the frame's tokenex_card holder, no sibling to remove, and exactly the two ciphertext fields, each a
+ * non-empty string and distinct from the other. substitutePaddleTokenex checks each against the pinned key
+ * for the /pay's environment; this is the shape gate the client runs before it acts.
+ */
+export function isPaddleTokenexServedSubstitution(sub) {
+    if (!sub || typeof sub !== 'object' || Array.isArray(sub))
+        return false;
+    const { encoding, at, fields, remove } = sub;
+    if (encoding !== 'json' || at !== SERVED_AT || !fields || typeof fields !== 'object' || Array.isArray(fields))
+        return false;
+    if (remove !== undefined && !(Array.isArray(remove) && remove.length === 0))
+        return false;
+    const named = fields;
+    const names = Object.keys(named);
+    if (names.length !== CIPHERTEXT_FIELDS.length || !CIPHERTEXT_FIELDS.every((name) => typeof named[name] === 'string' && named[name].length > 0))
+        return false;
+    return named.encrypted_card_number !== named.encrypted_cvv;
+}
+/**
+ * Whether the API's `paddle_tokenex_facts` beside an approved set is the five facts this SDK can write over
+ * the placeholder's: exactly the five keys, the three strings as strings and the two expiry parts as
+ * numbers. paddleTokenexSubstitutionOf checks the digits, range and network at the swap; this is the shape
+ * gate the client runs before it acts, so a malformed approval is refused before anything is written.
+ */
+export function isPaddleTokenexServedFacts(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const named = value;
+    const names = Object.keys(named);
+    if (names.length !== FACT_KEYS.length || !FACT_KEYS.every((name) => name in named))
+        return false;
+    return STRING_FACTS.every((name) => typeof named[name] === 'string' && named[name].length > 0)
+        && NUMBER_FACTS.every((name) => typeof named[name] === 'number' && Number.isInteger(named[name]));
+}
+/**
+ * The continuation of an approved Paddle TokenEx /pay: the paused body with the device's two ciphertexts
+ * written over the placeholder's at tokenex_card and the five facts over the placeholder's at metadata
+ * (payment-core substitutePaddleTokenex, which refuses a ciphertext that is not one under the pinned key
+ * for the /pay's environment, or one already in the paused body).
+ *
+ * Only into `approved`, the paused /pay the approval was created from: `url` and `body` must equal it byte
+ * for byte. The account-level TokenEx key is the same for every checkout of that seller, so the device's
+ * ciphertext could be decrypted in any later /pay of the same shape; binding it to the one request keeps
+ * this lane from ever submitting one checkout's ciphertext to another.
+ *
+ * Null when neither URL is a TokenEx /pay, so every other processor keeps the generic swap. Throws for any
+ * other body or URL, and for a substitution or facts the shape gates refuse, in each case before anything
+ * continues.
+ */
+export function paddleTokenexTokenContinuation(url, body, sub, facts, approved) {
+    if (paddleTokenexPayTarget(url) === null && paddleTokenexPayTarget(approved.url) === null)
+        return null;
+    if (url !== approved.url || body !== approved.body)
+        throw new Error('Refusing to substitute: the paused request is not the Paddle TokenEx /pay the cardholder approved.');
+    if (!isPaddleTokenexServedSubstitution(sub) || !isPaddleTokenexServedFacts(facts))
+        throw new Error('Refusing to substitute: the Paddle TokenEx approval is not two ciphertexts and five card facts.');
+    const substitution = { encrypted_card_number: sub.fields.encrypted_card_number, encrypted_cvv: sub.fields.encrypted_cvv, ...facts };
+    return { body: substitutePaddleTokenex(url, body, substitution) };
+}

package/dist/paypal-card-forms.d.ts

@@ -0,0 +1,73 @@
+/**
+ * PayPal's Card Fields and PayPal's guest card form, which this SDK refuses for every company until a
+ * synced recognizer takes the request.
+ *
+ * Read 2026-10-15 from PayPal's public bundles and card-free page reads (WooCommerce PayPal Payments
+ * 4.1.3 checkouts on PayPal JS SDK 5.0.582, card-field client 1.270.0; web-sdk v6 6.68.0):
+ *
+ *   Card Fields v5 (components=card-fields): each field is a frame on www.paypal.com/smart/card-field,
+ *   and at submit the number frame sends the typed card as plaintext JSON, a same-origin XHR:
+ *     POST https://www.paypal.com/v2/checkout/orders/<order id>/confirm-payment-source
+ *     {"payment_source":{"card":{"number","expiry":"YYYY-MM","security_code","name"?,"billing_address"?}}}
+ *   Card Fields v6 (web-sdk v6): the same request, sent to api-m.paypal.com.
+ *   Card Fields saving a card with no purchase: POST https://www.paypal.com/graphql?UpdateVaultSetupToken,
+ *     the card at variables.paymentSource.card.
+ *   PayPal's guest card form, behind the black "Debit or Credit Card" button: PayPal's checkout page
+ *     sends the card as POST https://www.paypal.com/graphql?OnboardGuestMutation, the number at
+ *     variables.card.cardNumber.
+ *   PayPal's sandbox serves each on www.sandbox.paypal.com and api-m.sandbox.paypal.com.
+ *
+ * An SDK without this guard let the agent's placeholder card reach PayPal there, and PayPal declined it.
+ * Both adapters arm these paths whatever the synced registry serves, and the pre-claim gate
+ * (paypalCardFormsPreClaim, pre-claim.ts) judges each POST:
+ *   - a Card Fields confirm whose body carries a number at payment_source.card.number aborts, reason
+ *     `unsupported_paypal_card_fields`, unless the synced registry recognizes it as a card request: an
+ *     org Agentcard turned PayPal Card Fields on for pauses and pays that confirm through the recognizer,
+ *     which judges the body itself;
+ *   - a GraphQL operation carrying a card aborts whatever the registry serves, since no recognizer pays
+ *     one: the guest form's card as `unsupported_paypal_guest_checkout`, a card saved with no purchase as
+ *     `unsupported_paypal_card_fields`;
+ *   - a body with no card (a PayPal wallet confirm, a saved card, every other GraphQL operation the
+ *     buttons send) continues untouched;
+ *   - a confirm the adapter could not read aborts that request alone, since nothing proves it carries no
+ *     card. A GraphQL post it could not read aborts only when its query names one of the two card
+ *     operations: PayPal's buttons send many others, and failing them would break PayPal's own wallet.
+ * Each abort holds the attachment as every unsupported refusal does: the page's next submit would carry
+ * the card again, so another way to pay needs a new attachment.
+ *
+ * A guest form PayPal opens in a popup window runs in another page, which an attachment covers only when
+ * the agent attaches the SDK to that page as well. PayPal's BIN lookup (/v2/payments/find-bin-details)
+ * reads the first digits the agent types and pays nothing; neither adapter intercepts it.
+ */
+import { paypalHostedFieldsBody } from './paypal-hosted-fields.js';
+export declare const PAYPAL_CARD_FIELDS_REASON: "unsupported_paypal_card_fields";
+export declare const PAYPAL_GUEST_CHECKOUT_REASON: "unsupported_paypal_guest_checkout";
+export type PaypalCardFormReason = typeof PAYPAL_CARD_FIELDS_REASON | typeof PAYPAL_GUEST_CHECKOUT_REASON;
+/** The hosts Card Fields sends its confirm to: v5 on www, v6 on api-m, live and sandbox. */
+export declare const PAYPAL_CARD_FIELDS_HOSTS: readonly string[];
+/** The hosts of PayPal's own pages, whose GraphQL endpoint takes the guest form's card and a card saved with no purchase. */
+export declare const PAYPAL_GRAPHQL_HOSTS: readonly string[];
+/**
+ * CDP Fetch patterns, armed on every attachment: the confirm on its four hosts and GraphQL on PayPal's
+ * two page hosts. Chrome sends the canonical URL, whose host is lower case, and the trailing `*` keeps a
+ * query or a trailing slash paused. Nothing else on www.paypal.com is armed.
+ */
+export declare const PAYPAL_CARD_FORM_PATTERNS: readonly string[];
+/** Whether this URL is the Card Fields confirm on one of its four hosts (https, standard port, no credentials). */
+export declare function isPaypalCardFieldsConfirm(url: string): boolean;
+/** Whether this URL is GraphQL on one of PayPal's two page hosts. */
+export declare function isPaypalGraphql(url: string): boolean;
+/** Whether this URL is any request the guard judges, for the Playwright route's predicate. */
+export declare function isPaypalCardFormUrl(url: string): boolean;
+/** Whether a GraphQL URL's query names one of the two card operations (`/graphql?OnboardGuestMutation`). */
+export declare function paypalGraphqlNamesCardOperation(url: string): boolean;
+/**
+ * What a GraphQL post carries, read as PayPal reads it (the last of a repeated key wins in both), for one
+ * operation or a batch of them: 'guest_card' when an operation's variables.card.cardNumber holds anything
+ * but null or an empty string, 'saved_card' when an operation's variables.paymentSource.card is an object,
+ * 'no_card' for any other JSON object or array of them, and 'unreadable' for a body the adapter could not
+ * read (null), an empty one, or one that is neither.
+ */
+export declare function paypalGraphqlCard(body: string | null): 'guest_card' | 'saved_card' | 'no_card' | 'unreadable';
+/** What a Card Fields confirm carries: its body is the Orders v2 shape Hosted Fields also sends. */
+export declare const paypalCardFieldsBody: typeof paypalHostedFieldsBody;

package/dist/paypal-card-forms.js

@@ -0,0 +1,126 @@
+/**
+ * PayPal's Card Fields and PayPal's guest card form, which this SDK refuses for every company until a
+ * synced recognizer takes the request.
+ *
+ * Read 2026-10-15 from PayPal's public bundles and card-free page reads (WooCommerce PayPal Payments
+ * 4.1.3 checkouts on PayPal JS SDK 5.0.582, card-field client 1.270.0; web-sdk v6 6.68.0):
+ *
+ *   Card Fields v5 (components=card-fields): each field is a frame on www.paypal.com/smart/card-field,
+ *   and at submit the number frame sends the typed card as plaintext JSON, a same-origin XHR:
+ *     POST https://www.paypal.com/v2/checkout/orders/<order id>/confirm-payment-source
+ *     {"payment_source":{"card":{"number","expiry":"YYYY-MM","security_code","name"?,"billing_address"?}}}
+ *   Card Fields v6 (web-sdk v6): the same request, sent to api-m.paypal.com.
+ *   Card Fields saving a card with no purchase: POST https://www.paypal.com/graphql?UpdateVaultSetupToken,
+ *     the card at variables.paymentSource.card.
+ *   PayPal's guest card form, behind the black "Debit or Credit Card" button: PayPal's checkout page
+ *     sends the card as POST https://www.paypal.com/graphql?OnboardGuestMutation, the number at
+ *     variables.card.cardNumber.
+ *   PayPal's sandbox serves each on www.sandbox.paypal.com and api-m.sandbox.paypal.com.
+ *
+ * An SDK without this guard let the agent's placeholder card reach PayPal there, and PayPal declined it.
+ * Both adapters arm these paths whatever the synced registry serves, and the pre-claim gate
+ * (paypalCardFormsPreClaim, pre-claim.ts) judges each POST:
+ *   - a Card Fields confirm whose body carries a number at payment_source.card.number aborts, reason
+ *     `unsupported_paypal_card_fields`, unless the synced registry recognizes it as a card request: an
+ *     org Agentcard turned PayPal Card Fields on for pauses and pays that confirm through the recognizer,
+ *     which judges the body itself;
+ *   - a GraphQL operation carrying a card aborts whatever the registry serves, since no recognizer pays
+ *     one: the guest form's card as `unsupported_paypal_guest_checkout`, a card saved with no purchase as
+ *     `unsupported_paypal_card_fields`;
+ *   - a body with no card (a PayPal wallet confirm, a saved card, every other GraphQL operation the
+ *     buttons send) continues untouched;
+ *   - a confirm the adapter could not read aborts that request alone, since nothing proves it carries no
+ *     card. A GraphQL post it could not read aborts only when its query names one of the two card
+ *     operations: PayPal's buttons send many others, and failing them would break PayPal's own wallet.
+ * Each abort holds the attachment as every unsupported refusal does: the page's next submit would carry
+ * the card again, so another way to pay needs a new attachment.
+ *
+ * A guest form PayPal opens in a popup window runs in another page, which an attachment covers only when
+ * the agent attaches the SDK to that page as well. PayPal's BIN lookup (/v2/payments/find-bin-details)
+ * reads the first digits the agent types and pays nothing; neither adapter intercepts it.
+ */
+import { paypalHostedFieldsBody } from './paypal-hosted-fields.js';
+export const PAYPAL_CARD_FIELDS_REASON = 'unsupported_paypal_card_fields';
+export const PAYPAL_GUEST_CHECKOUT_REASON = 'unsupported_paypal_guest_checkout';
+/** The hosts Card Fields sends its confirm to: v5 on www, v6 on api-m, live and sandbox. */
+export const PAYPAL_CARD_FIELDS_HOSTS = Object.freeze(['www.paypal.com', 'www.sandbox.paypal.com',
+    'api-m.paypal.com', 'api-m.sandbox.paypal.com']);
+/** The hosts of PayPal's own pages, whose GraphQL endpoint takes the guest form's card and a card saved with no purchase. */
+export const PAYPAL_GRAPHQL_HOSTS = Object.freeze(['www.paypal.com', 'www.sandbox.paypal.com']);
+const CONFIRM_PATH = /^\/v2\/checkout\/orders\/[^/]+\/confirm-payment-source\/?$/;
+const GRAPHQL_PATH = /^\/graphql\/?$/;
+/** The two GraphQL operations that carry a card, as PayPal's clients name them in the query string. */
+const CARD_OPERATIONS = ['OnboardGuestMutation', 'UpdateVaultSetupToken'];
+/**
+ * CDP Fetch patterns, armed on every attachment: the confirm on its four hosts and GraphQL on PayPal's
+ * two page hosts. Chrome sends the canonical URL, whose host is lower case, and the trailing `*` keeps a
+ * query or a trailing slash paused. Nothing else on www.paypal.com is armed.
+ */
+export const PAYPAL_CARD_FORM_PATTERNS = Object.freeze([
+    ...PAYPAL_CARD_FIELDS_HOSTS.map((host) => `https://${host}/v2/checkout/orders/*/confirm-payment-source*`),
+    ...PAYPAL_GRAPHQL_HOSTS.map((host) => `https://${host}/graphql*`),
+]);
+function paypalUrl(url, hosts, path) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    return parsed.protocol === 'https:' && !parsed.port && !parsed.username && !parsed.password
+        && hosts.includes(parsed.hostname.toLowerCase()) && path.test(parsed.pathname) ? parsed : null;
+}
+/** Whether this URL is the Card Fields confirm on one of its four hosts (https, standard port, no credentials). */
+export function isPaypalCardFieldsConfirm(url) {
+    return paypalUrl(url, PAYPAL_CARD_FIELDS_HOSTS, CONFIRM_PATH) !== null;
+}
+/** Whether this URL is GraphQL on one of PayPal's two page hosts. */
+export function isPaypalGraphql(url) {
+    return paypalUrl(url, PAYPAL_GRAPHQL_HOSTS, GRAPHQL_PATH) !== null;
+}
+/** Whether this URL is any request the guard judges, for the Playwright route's predicate. */
+export function isPaypalCardFormUrl(url) {
+    return isPaypalCardFieldsConfirm(url) || isPaypalGraphql(url);
+}
+/** Whether a GraphQL URL's query names one of the two card operations (`/graphql?OnboardGuestMutation`). */
+export function paypalGraphqlNamesCardOperation(url) {
+    const parsed = paypalUrl(url, PAYPAL_GRAPHQL_HOSTS, GRAPHQL_PATH);
+    return parsed !== null && CARD_OPERATIONS.some((name) => parsed.searchParams.has(name));
+}
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const present = (value) => value !== undefined && value !== null && value !== '';
+/**
+ * What a GraphQL post carries, read as PayPal reads it (the last of a repeated key wins in both), for one
+ * operation or a batch of them: 'guest_card' when an operation's variables.card.cardNumber holds anything
+ * but null or an empty string, 'saved_card' when an operation's variables.paymentSource.card is an object,
+ * 'no_card' for any other JSON object or array of them, and 'unreadable' for a body the adapter could not
+ * read (null), an empty one, or one that is neither.
+ */
+export function paypalGraphqlCard(body) {
+    if (typeof body !== 'string' || body === '')
+        return 'unreadable';
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return 'unreadable';
+    }
+    const operations = Array.isArray(parsed) ? parsed : [parsed];
+    if (operations.length === 0 || !operations.every(record))
+        return 'unreadable';
+    let carried = 'no_card';
+    for (const operation of operations) {
+        const variables = operation.variables;
+        if (!record(variables))
+            continue;
+        if (record(variables.card) && present(variables.card.cardNumber))
+            return 'guest_card';
+        if (record(variables.paymentSource) && record(variables.paymentSource.card))
+            carried = 'saved_card';
+    }
+    return carried;
+}
+/** What a Card Fields confirm carries: its body is the Orders v2 shape Hosted Fields also sends. */
+export const paypalCardFieldsBody = paypalHostedFieldsBody;

package/dist/pre-claim.d.ts

@@ -14,6 +14,7 @@ import { type PayrailsSessionCapture, type PayrailsSidecar } from './payrails.js
 import { type VerifoneProfile } from './verifone.js';
 import { type WorldlineMyCheckoutProducts } from './worldline-mycheckout.js';
 import { type PaddleVgsPayGate } from './paddle-vgs-pay.js';
+import { type EbanxFollowUps } from './ebanx.js';
 /** The native Stripe step the gate claimed, or null when none was: exactly what StripeCheckoutGate.claim returns. */
 type StripeStep = ReturnType<StripeCheckoutGate['claim']>;
 /** A synthetic response a gate fulfills locally. The effect applies CORS and encoding. */
@@ -98,6 +99,20 @@ export interface PreClaimContext {
         verifoneProfileOf?(url: string): VerifoneProfile | null;
         cardOnFilePolicy?(url: string, method?: string): string | null;
         withoutCard?(url: string, body: string | null | undefined): 'continue' | 'refuse' | null;
+        /** VaultClient.sendEbanxFollowUp: a send an approved EBANX token request covers, from the cardholder's device. */
+        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;
+        }>;
     };
     guards: {
         matches(url: string, method?: string): boolean;
@@ -117,11 +132,15 @@ export interface PreClaimContext {
     eprotect?: EprotectGate;
     readDocumentUrl: () => Promise<string>;
     lifecycle: CheckoutLifecycle;
-    /** isEngaged and observeUnprepared are called only for an armed merchant profile's card request or a Fiserv card capture. */
+    /**
+     * isEngaged and observeUnprepared are called only for an armed merchant profile's card request or a Fiserv card capture.
+     * creditguardStanding, only for a request on a CreditGuard PPS host (PreparationGate.creditguardStanding); absent reads as 'none'.
+     */
     preparationGate: {
         invalidate(reason: string): void;
         isEngaged(): boolean;
         observeUnprepared(): void;
+        creditguardStanding?(txId: string): 'none' | 'ready' | 'refuse';
     };
     effects: PreClaimEffects;
     onEvent?: (event: PreClaimEvent) => void;
@@ -196,6 +215,12 @@ export interface PreClaimContext {
      * checkout services are not this gate's.
      */
     paddleVgsPay?: PaddleVgsPayGate;
+    /**
+     * The attachment's approved EBANX token request and the sends claimed under it (ebanx.ts EbanxFollowUps).
+     * Absent, or holding no approval whose read named a window, and every EBANX 3-D Secure call and card confirm
+     * is refused, as before the approval covered them.
+     */
+    ebanx?: EbanxFollowUps;
 }
 /**
  * The URL an event may name for a request. For an armed merchant profile's
@@ -214,11 +239,24 @@ export type PreClaimGate = (ctx: PreClaimContext) => PreClaimDecision | undefine
 export declare const MERCHANT_BODY_UNREADABLE = "the paused request carries no body the SDK could read, so Agentcard cannot tell whether it carries a card";
 export declare const verifonePreClaim: PreClaimGate;
 export declare const fiservPreClaim: PreClaimGate;
+/**
+ * Whether an adapter must hand this request to the pre-claim gates as a CreditGuard page's own call
+ * beside its submit: a companion endpoint (payment-core creditguardCompanionCall, as loosely as a
+ * request could spell one) while this build's registry serves CreditGuard. The CDP adapter pauses
+ * them already through the recognizer's host-wide URL patterns; attachToPlaywright's route predicate,
+ * which otherwise sees only the submit, asks this.
+ */
+export declare function isArmedCreditguardCall(vault: {
+    recognizesProcessor?(psp: string): boolean;
+} | undefined, url: string): boolean;
 export declare const ekashuPreClaim: PreClaimGate;
+export declare const redsysPreClaim: PreClaimGate;
 export declare const paypalHostedFieldsPreClaim: PreClaimGate;
+export declare const paypalCardFormsPreClaim: PreClaimGate;
 export declare const cybersourceSecureAcceptancePreClaim: PreClaimGate;
 export declare const worldlineMyCheckoutPreClaim: PreClaimGate;
 export declare const paddleVgsPayPreClaim: PreClaimGate;
+export declare const ebanxPreClaim: PreClaimGate;
 /** The processor gates, in order. A new family adds one entry here; the terminal
  * arbiter runs after all of them and is not part of this list. A gate appended
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or