@agent-cards/sdk 0.23.19 → 0.23.21

package/dist/tokenex-iframe.js

@@ -0,0 +1,195 @@
+// TokenEx hosted iframe v3 (psp `tokenex_iframe`), on htp.tokenex.com (live) and test-htp.tokenex.com (test):
+// the card form JetBlue's booking checkout mounts for the card number and the CVV. The cardholder name and the
+// expiry stay on JetBlue's own page. TokenEx's card-number frame, a cross-origin iframe the merchant page never
+// reads, takes the CVV from its same-origin CVV frame and sends the whole card in one XHR: POST to its own
+// document URL, query included, application/json. This module holds what the SDK decides about that frame's
+// requests. The rules themselves are payment-core's (tokenex-iframe.generated.ts): the API applies the same ones
+// at create, and the cardholder's device applies them again, with the account pin and the brand rule, before it
+// writes a card.
+//
+// The processor ships dark. The API serves the tokenex_iframe recognizer only to a build that declares the
+// `tokenex_iframe_tokenize` capability (client.ts SUPPORTED_CAPABILITIES) and only to an org Agentcard enabled
+// for it, so an SDK the API never served it leaves every TokenEx request alone.
+import { TOKENEX_IFRAME_CAPABILITY as CORE_CAPABILITY, TOKENEX_IFRAME_HOSTS, TOKENEX_IFRAME_PATH, TOKENEX_IFRAME_PSP as CORE_PSP, classifyTokenexIframeRequest, sanitizeTokenexIframeResponse, tokenexIframeBodyVerdict, tokenexIframeCardType, tokenexIframeResponseOutcome, tokenexIframeTarget, } from './tokenex-iframe.generated.js';
+/** The PSP id the API and the recognizer name this lane. */
+export const TOKENEX_IFRAME_PSP = CORE_PSP;
+/** The dark-launch capability the API serves the tokenex_iframe recognizer behind. */
+export const TOKENEX_IFRAME_CAPABILITY = CORE_CAPABILITY;
+export const INVALID_TOKENEX_IFRAME_REQUEST = 'invalid_tokenex_iframe_request';
+/** True when the URL parses onto one of TokenEx's two iframe hosts and the /iframe/v3 path, however it is spelled or queried. */
+export function isTokenexIframePath(url) {
+    try {
+        const parsed = new URL(url);
+        return TOKENEX_IFRAME_HOSTS.includes(parsed.hostname.toLowerCase().replace(/\.$/, ''))
+            && parsed.pathname.toLowerCase() === TOKENEX_IFRAME_PATH;
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether this build's registry serves the TokenEx iframe: a company Agentcard turned it on for, on a build that declares it. */
+export function servesTokenexIframe(vault) {
+    return typeof vault?.recognizesProcessor === 'function' && vault.recognizesProcessor(TOKENEX_IFRAME_PSP);
+}
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on the frame's /iframe/v3 path and this
+ * build's registry serves the TokenEx iframe. The recognizer matches only the exact card URL, so a variant (another
+ * query, a case or dot spelling) would otherwise never reach the gate that refuses it. attachToPlaywright's route
+ * predicate asks this; attachToCdp arms the two hosts from the recognizer's own host list.
+ */
+export function isArmedTokenexIframeUrl(vault, url) {
+    return isTokenexIframePath(url) && servesTokenexIframe(vault);
+}
+/**
+ * The pause decision for a POST on the frame's path, by payment-core's classifyTokenexIframeRequest:
+ *   'card'  the exact card URL with the JSON content type and the sound pcicvv card post bound to its query: it pauses;
+ *   'invalid_tokenex_iframe_request'  a post with a value in Data that is not that: it is refused in the browser;
+ *   null    not a card post (no value in Data, another path, BinLookup, Forter): the SDK's ordinary handling
+ *           decides, and an empty-Data post continues untouched through the recognizer's passWithoutCard.
+ * A URL longer than payment-core reads (over 2,048 characters) classifies as null, as an unrelated request does, and
+ * the exact recognizer refuses it too, so a post on the frame's own path that carries a value in Data is refused here
+ * rather than sent to TokenEx with the agent's placeholder.
+ */
+export function tokenexIframePauseDecision(request) {
+    const verdict = classifyTokenexIframeRequest(request.url, 'POST', request.body ?? '', request.headers ?? {});
+    if (verdict === 'card')
+        return 'card';
+    if (verdict !== null)
+        return INVALID_TOKENEX_IFRAME_REQUEST;
+    return isTokenexIframePath(request.url) && tokenexIframeBodyVerdict(request.body ?? '', undefined).verdict !== 'continue'
+        ? INVALID_TOKENEX_IFRAME_REQUEST : null;
+}
+/**
+ * The answer the paused card post may receive, rebuilt from payment-core's allow-list under a JSON content type:
+ * only TokenEx's 200 with a sound sixTOKENfour token (tokenexIframeResponseOutcome reads it as approved), keys TokenEx
+ * documents for a success and nothing else (sanitizeTokenexIframeResponse). Null for anything else: an error answer,
+ * another status, a body out of bounds. The frame adds its own `cardType` before the page reads the answer.
+ */
+export function tokenexIframePageAnswer(status, body) {
+    try {
+        if (tokenexIframeResponseOutcome(status, body, undefined).outcome !== 'approved')
+            return null;
+        return { status: 200, headers: { 'content-type': 'application/json' }, body: sanitizeTokenexIframeResponse(body) };
+    }
+    catch {
+        return null;
+    }
+}
+// ── The placeholder card ────────────────────────────────────────────────────
+// The frame stamps `cardType` onto TokenEx's answer from ITS OWN reading of the digits the agent typed, not from the
+// card TokenEx tokenized, and the page reads that brand (JetBlue's payment step goes on with it). So the cardholder's
+// device refuses a card whose brand the placeholder does not share (payment-core tokenexIframeBrandRefusal), and it
+// proves only Visa, Mastercard and American Express by the frame's own table. placeholderCard() therefore gives a
+// TokenEx form only a number the frame reads as the stored card's own network, and refuses every other network.
+/** The frame's cardType for each network GET /api/v2/vault_cards names, for the three this lane proves. */
+const FRAME_CARD_TYPE = Object.freeze({ visa: 'visa', mastercard: 'masterCard', amex: 'americanExpress' });
+/** Whether the frame reads `number` as the network `brand` (lowercase, as GET /api/v2/vault_cards names it). */
+export function tokenexIframePlaceholderFits(brand, number) {
+    const type = Object.prototype.hasOwnProperty.call(FRAME_CARD_TYPE, brand) ? FRAME_CARD_TYPE[brand] : undefined;
+    return type !== undefined && tokenexIframeCardType(number) === type;
+}
+// ── The repeat rule ─────────────────────────────────────────────────────────
+// TokenEx's frame answers a repeat itself: tokenize() hands the page its previous answer again, with no request,
+// while Data and the CVV are unchanged and its five-minute timer (newAttemptTimeout, 300 s from the frame's load) has
+// not set newAttempt. So the requests this build sees after an approval are of two kinds:
+//   - the same bytes again, from the same frame: the timer fired, or the frame was reset or reloaded with the same
+//     URL (and so the same AuthenticationKey and Timestamp). TokenEx would mint another token for the same card;
+//   - another Data or CVV: the agent typed another placeholder. The frame stamps cardType from the new digits, so an
+//     earlier token under them could carry another brand to the page than the card's.
+// So once an approved answer is handed to a card post, a later post from the same frame with the same URL and the
+// same body, byte for byte, is answered here with that stored answer: no create, no prompt, no second card sent.
+// Any other post is a new question: another placeholder or CVV, another frame (JetBlue re-creating the iframe), another
+// key or Timestamp (a reloaded frame JetBlue minted a new key for). The answer belongs to one approval's handoff (the
+// gate in pre-claim.ts hands it out only while that approval is the attachment's current one, and once the answer
+// reached the page only while the application's merchant resolver reports the order pending, as for Datatrans) and
+// ends with the key the post carries (its Timestamp plus its ExpiresInSeconds, at most 1,200 s), so an approval that
+// arrives ten minutes into a twenty-minute key keeps its answer for the remaining ten: past the key TokenEx would
+// refuse the same post as "Invalid Authentication Key". There is no idle bound as Datatrans has: the frame re-sends
+// unchanged bytes only on its own five-minute timer, so a five-minute quiet rule would end most repeats before they came.
+/** The longest an iframe key lives, and so the longest a stored answer is handed out: TokenEx's ExpiresInSeconds maximum. */
+export const TOKENEX_IFRAME_REPEAT_WINDOW_MS = 1_200_000;
+/** The most answers one attachment keeps; the oldest goes first. */
+const MAX_REMEMBERED = 8;
+/** The millisecond the merchant's server minted the post's iframe key, from its `Timestamp` (yyyyMMddHHmmss, UTC). */
+function keyMintedAtMs(stamp) {
+    if (stamp === undefined || !/^[0-9]{14}$/.test(stamp))
+        return null;
+    const at = Date.UTC(Number(stamp.slice(0, 4)), Number(stamp.slice(4, 6)) - 1, Number(stamp.slice(6, 8)), Number(stamp.slice(8, 10)), Number(stamp.slice(10, 12)), Number(stamp.slice(12, 14)));
+    return Number.isFinite(at) ? at : null;
+}
+/**
+ * When the post's own iframe key expires: its Timestamp plus its ExpiresInSeconds (TokenEx's default 1,200 s when
+ * the query names none), at most the window. An approval that reaches the page partway through a key's life therefore
+ * keeps its answer for the rest of that key and no longer, where a lifetime counted from the answer would outlive the
+ * key TokenEx checks. A Timestamp this clock has not reached counts from now, so the answer never outlives the key
+ * either way.
+ */
+function keyDeadlineMs(url, now) {
+    const target = tokenexIframeTarget(url);
+    if (!target)
+        return null;
+    const named = Number(target.query.get('ExpiresInSeconds') ?? '1200');
+    const minted = keyMintedAtMs(target.query.get('Timestamp'));
+    if (minted === null || !Number.isSafeInteger(named) || named <= 0)
+        return null;
+    return Math.min(minted, now) + Math.min(named * 1000, TOKENEX_IFRAME_REPEAT_WINDOW_MS);
+}
+/**
+ * The approved TokenEx answers one attachment handed to a card post, per frame. `frame` is the adapter's identity
+ * for the request's frame (the CDP frameId of the out-of-process iframe, the Playwright Frame); a request whose
+ * frame is unknown is never remembered and never answered. Only an answer payment-core reads as approved (a sound
+ * sixTOKENfour token) to the sound card post is kept: an error answer leaves the next post a new question, so the
+ * page can try again.
+ */
+export class TokenexIframeRepeats {
+    now;
+    remembered = [];
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    /**
+     * Keep the answer a token replay handed to this card post, when TokenEx approved it. Called after the answer
+     * reached the browser, so it never throws: a failure here only leaves the page's next post a new question.
+     */
+    remember(frame, url, body, replay) {
+        try {
+            if (frame === undefined || frame === null || frame === '' || typeof body !== 'string')
+                return;
+            if (replay.mode !== 'token')
+                return;
+            if (tokenexIframeBodyVerdict(body, url).verdict !== 'card')
+                return;
+            const until = keyDeadlineMs(url, this.now());
+            if (until === null || until <= this.now())
+                return;
+            if (tokenexIframeResponseOutcome(replay.status, replay.body, undefined).outcome !== 'approved')
+                return;
+            this.prune();
+            this.remembered = this.remembered.filter((entry) => !(entry.frame === frame && entry.url === url && entry.body === body));
+            this.remembered.push({ frame, url, body, authorizationId: replay.authorizationId, status: replay.status,
+                headers: { ...replay.headers }, answer: replay.body, until });
+            if (this.remembered.length > MAX_REMEMBERED)
+                this.remembered.shift();
+        }
+        catch { /* see above: the next post is a new question */ }
+    }
+    /**
+     * The stored answer for the same frame's same post, byte for byte, or null. Only an answer from `authorizationId`,
+     * the approval the attachment is handing off now, is handed out, and every answer from another approval is
+     * dropped: a later authorization ends the window of every earlier one.
+     */
+    answerFor(frame, url, body, authorizationId) {
+        if (frame === undefined || frame === null || frame === '' || typeof body !== 'string' || !authorizationId)
+            return null;
+        this.prune();
+        this.remembered = this.remembered.filter((entry) => entry.authorizationId === authorizationId);
+        const entry = this.remembered.find((candidate) => candidate.frame === frame && candidate.url === url && candidate.body === body);
+        if (!entry)
+            return null;
+        return { authorizationId: entry.authorizationId, response: { status: entry.status, headers: { ...entry.headers }, body: entry.answer } };
+    }
+    prune() {
+        const now = this.now();
+        this.remembered = this.remembered.filter((entry) => now < entry.until);
+    }
+}

package/dist/transbank.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Transbank's Webpay Plus (webpay3g.transbank.cl, the card payment form most Chilean shops send a buyer to), as this
+ * SDK reads it.
+ *
+ * The merchant's server creates the transaction at Transbank and sends the buyer's browser to Webpay with a GET,
+ * https://webpay3g.transbank.cl/webpayserver/initTransaction?token_ws=<64 lowercase hex>, the way the official
+ * WooCommerce plugin redirects. That GET carries no card and nothing but Transbank's token, and it is the one request
+ * a build that declares Webpay's capability pauses for Webpay (hosted-entry.ts): the cardholder's device repeats it
+ * over the end-to-end TLS relay and sends Webpay's card steps inside the session it opens (payment-core
+ * processors/transbank.js). Everything else the agent's browser sends Webpay spends the token or carries a card the
+ * agent typed: the token's one submit (/webpayserver/init_transaction.cgi), the card lookup and card check under
+ * /webpayserver/wswebpay/services/, and the card post (/webpayserver/bp_control.cgi). Once Webpay is served this SDK
+ * aborts every one of them (pre-claim.ts transbankPreClaim), so the token is never spent in the agent's browser and
+ * no placeholder card reaches Webpay. Only the link exactly as the merchant's redirect writes it is the entry; any
+ * other spelling would be handed on to Webpay's own route, which these rules never see.
+ *
+ * TRANSBANK_HOSTS is payment-core's TRANSBANK_HOSTS, and isTransbankEntryUrl is payment-core's rule of the same name;
+ * transbank.test.mjs pins both to payment-core on every case payment-core's own tests list.
+ */
+export declare const TRANSBANK_PSP = "transbank_webpay";
+/** The dark-launch capability the API serves Webpay's recognizer behind (payment-core definitions.js). */
+export declare const TRANSBANK_CAPABILITY = "transbank_webpay_hosted_payment_page";
+/** Webpay's live host and Transbank's integration host, each a host of its own entry. */
+export declare const TRANSBANK_HOSTS: readonly string[];
+/**
+ * Whether a URL is Webpay's entry exactly as the merchant's redirect writes it: https, one of Transbank's two hosts in
+ * lower case, no port, credentials or fragment, the path /webpayserver/initTransaction, and a query of the one
+ * `token_ws` parameter holding 64 lowercase hex characters. A string that parses to another spelling is not it.
+ */
+export declare function isTransbankEntryUrl(raw: unknown): boolean;
+/** Whether this URL is on one of Webpay's two hosts (https, no credentials, any port, a trailing dot or not). */
+export declare function isTransbankHost(url: string): boolean;
+/** Whether this build's registry serves Webpay's entry: a company Agentcard turned Webpay on for, on a build that declares it. */
+export declare function servesTransbank(vault: {
+    isCardRequest(url: string, method?: string): boolean;
+} | undefined): boolean;
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on one of Webpay's hosts and this build's
+ * registry serves Webpay. attachToCdp pauses every request there through the recognizer's host patterns;
+ * attachToPlaywright's route predicate asks this, so both adapters show the Webpay gate every request to a Webpay host
+ * once Webpay is served.
+ */
+export declare function isArmedTransbankUrl(vault: {
+    isCardRequest(url: string, method?: string): boolean;
+} | undefined, url: string): boolean;

package/dist/transbank.js

@@ -0,0 +1,73 @@
+/**
+ * Transbank's Webpay Plus (webpay3g.transbank.cl, the card payment form most Chilean shops send a buyer to), as this
+ * SDK reads it.
+ *
+ * The merchant's server creates the transaction at Transbank and sends the buyer's browser to Webpay with a GET,
+ * https://webpay3g.transbank.cl/webpayserver/initTransaction?token_ws=<64 lowercase hex>, the way the official
+ * WooCommerce plugin redirects. That GET carries no card and nothing but Transbank's token, and it is the one request
+ * a build that declares Webpay's capability pauses for Webpay (hosted-entry.ts): the cardholder's device repeats it
+ * over the end-to-end TLS relay and sends Webpay's card steps inside the session it opens (payment-core
+ * processors/transbank.js). Everything else the agent's browser sends Webpay spends the token or carries a card the
+ * agent typed: the token's one submit (/webpayserver/init_transaction.cgi), the card lookup and card check under
+ * /webpayserver/wswebpay/services/, and the card post (/webpayserver/bp_control.cgi). Once Webpay is served this SDK
+ * aborts every one of them (pre-claim.ts transbankPreClaim), so the token is never spent in the agent's browser and
+ * no placeholder card reaches Webpay. Only the link exactly as the merchant's redirect writes it is the entry; any
+ * other spelling would be handed on to Webpay's own route, which these rules never see.
+ *
+ * TRANSBANK_HOSTS is payment-core's TRANSBANK_HOSTS, and isTransbankEntryUrl is payment-core's rule of the same name;
+ * transbank.test.mjs pins both to payment-core on every case payment-core's own tests list.
+ */
+export const TRANSBANK_PSP = 'transbank_webpay';
+/** The dark-launch capability the API serves Webpay's recognizer behind (payment-core definitions.js). */
+export const TRANSBANK_CAPABILITY = 'transbank_webpay_hosted_payment_page';
+/** Webpay's live host and Transbank's integration host, each a host of its own entry. */
+export const TRANSBANK_HOSTS = Object.freeze(['webpay3g.transbank.cl', 'webpay3gint.transbank.cl']);
+const TRANSBANK_ENTRY_PATH = '/webpayserver/initTransaction';
+// A Webpay token as Transbank's REST reference defines it: 64 lowercase hex characters.
+const TOKEN_QUERY = /^\?token_ws=[0-9a-f]{64}$/;
+// An entry in the shape the merchant's redirect writes it: the registry reads Webpay as served when it takes this as a GET entry.
+const TRANSBANK_SAMPLE_ENTRY = `https://webpay3g.transbank.cl${TRANSBANK_ENTRY_PATH}?token_ws=${'0'.repeat(64)}`;
+/**
+ * Whether a URL is Webpay's entry exactly as the merchant's redirect writes it: https, one of Transbank's two hosts in
+ * lower case, no port, credentials or fragment, the path /webpayserver/initTransaction, and a query of the one
+ * `token_ws` parameter holding 64 lowercase hex characters. A string that parses to another spelling is not it.
+ */
+export function isTransbankEntryUrl(raw) {
+    if (typeof raw !== 'string' || raw.length > 256 || raw.includes('#'))
+        return false;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return false;
+    }
+    if (url.href !== raw || url.protocol !== 'https:' || url.port || url.username || url.password)
+        return false;
+    return TRANSBANK_HOSTS.includes(url.hostname) && url.pathname === TRANSBANK_ENTRY_PATH && TOKEN_QUERY.test(url.search);
+}
+/** Whether this URL is on one of Webpay's two hosts (https, no credentials, any port, a trailing dot or not). */
+export function isTransbankHost(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return parsed.protocol === 'https:' && !parsed.username && !parsed.password
+        && TRANSBANK_HOSTS.includes(parsed.hostname.toLowerCase().replace(/\.$/, ''));
+}
+/** Whether this build's registry serves Webpay's entry: a company Agentcard turned Webpay on for, on a build that declares it. */
+export function servesTransbank(vault) {
+    return typeof vault?.isCardRequest === 'function' && vault.isCardRequest(TRANSBANK_SAMPLE_ENTRY, 'GET');
+}
+/**
+ * Whether an adapter must hand this request to the pre-claim gates: it is on one of Webpay's hosts and this build's
+ * registry serves Webpay. attachToCdp pauses every request there through the recognizer's host patterns;
+ * attachToPlaywright's route predicate asks this, so both adapters show the Webpay gate every request to a Webpay host
+ * once Webpay is served.
+ */
+export function isArmedTransbankUrl(vault, url) {
+    return isTransbankHost(url) && servesTransbank(vault);
+}

package/dist/twoc2p.d.ts

@@ -0,0 +1,54 @@
+/** The PSP id the API and the recognizer name this lane, re-exported so the client dispatches by it. */
+export { TWOC2P_PSP } from './twoc2p.generated.js';
+/** The dark-launch capability a build declares when it fills a 2C2P Payment with the device's card field. */
+export declare const TWOC2P_CAPABILITY = "twoc2p_secure_pay";
+/** A cse substitution as the API serves it (substitute.ts Substitutions): here the one card field. */
+interface TwoC2pServedSubstitution {
+    encoding: string;
+    at: string;
+    fields: Record<string, string>;
+    remove?: string[];
+}
+/**
+ * Whether an approved 2C2P authorization's served substitution is one this SDK can continue: JSON at payment.data,
+ * no sibling to remove, and exactly the one card field, a non-empty string. substituteTwoC2p checks the field
+ * against the pinned key for the Payment's environment; this is the shape gate the continuation runs first.
+ */
+export declare function isTwoC2pServedSubstitution(sub: unknown): sub is TwoC2pServedSubstitution;
+/** The part of the client a refused continuation retires its approval through. */
+interface TwoC2pRetiringClient {
+    cancelAuthorization?: (authorizationId: string, reason: 'merchant_never_retried') => Promise<unknown>;
+}
+/**
+ * The retirement a refused 2C2P continuation runs (twoC2pContinuation's `retire`), or undefined for a client that
+ * cannot cancel: the approval is cancelled as merchant_never_retried, since its field went to no request, and the
+ * API stops serving the field. The paused request fails at once, so the cancel is not awaited; when the API does not
+ * confirm it, `onEvent` hears approval_retire_unconfirmed with the authorization's id. The API's sweep drops the field
+ * once its readable window passes either way.
+ */
+export declare function twoC2pRetire(client: TwoC2pRetiringClient | undefined, authorizationId: string, onEvent?: (event: {
+    type: string;
+    detail?: unknown;
+}) => void): (() => void) | undefined;
+/** The paused request an approval was created from: the URL and body the API reviewed at create. */
+export interface TwoC2pApprovedRequest {
+    url: string;
+    body: string;
+}
+/**
+ * The continuation of an approved 2C2P Payment: the paused body with the device's card field written over the
+ * placeholder's (payment-core substituteTwoC2p, which refuses a field that is not one under the pinned key for the
+ * Payment's environment, or one already in the paused body).
+ *
+ * Only into `approved`, the paused Payment the approval was created from: `url` and `body` must equal it byte for
+ * byte. 2C2P's key is the same for every merchant, so the field would pay any later Payment of the same shape;
+ * binding it to the one request keeps this lane from ever writing one payment's field into another.
+ *
+ * Null when neither URL is a 2C2P Payment, so every other processor keeps its own swap. Throws for any other body or
+ * URL, and for a substitution the shape gate or the swap refuses, in each case before anything continues. A refusal
+ * means the device's field went to no request, so `retire` runs first: the caller retires the approval as
+ * merchant_never_retried, and the API stops serving the field (cdp.ts cseContinuation).
+ */
+export declare function twoC2pContinuation(url: string, body: string, sub: unknown, approved: TwoC2pApprovedRequest, retire?: () => void): {
+    body: string;
+} | null;

package/dist/twoc2p.generated.d.ts

@@ -0,0 +1,33 @@
+declare var TWOC2P_PSP: string;
+declare var TWOC2P_CAPABILITY: string;
+declare var TWOC2P_OPERATION: string;
+declare var TWOC2P_SCHEME: string;
+declare var TWOC2P_FIELD_AT: string;
+declare var TWOC2P_FIELD: string;
+declare var TWOC2P_REVIEWED_BUILDS: readonly string[];
+declare var TWOC2P_REFUSAL_CODES: readonly string[];
+declare function twoC2pPaymentTarget(url: any): Readonly<{
+    environment: "production" | "sandbox";
+    version: string;
+    reviewed: boolean;
+}> | null;
+declare function twoC2pPaymentCarriesCard(body: any): boolean;
+declare function twoC2pBodyVerdict(body: any, keyBytes?: number, environment?: undefined): Readonly<{
+    verdict: "continue";
+}> | Readonly<{
+    verdict: "refuse";
+    code: any;
+}> | Readonly<{
+    verdict: "card";
+}>;
+declare function twoC2pRequestRefusal(request: any, environment: any): any;
+declare function twoC2pRefusalMessage(code: any): any;
+declare function encryptTwoC2pCard(card: any, environment: any, facilities?: {}): Promise<string>;
+declare function twoC2pSubstitutionOf(value: any, environment: any): any;
+declare function substituteTwoC2p(url: any, body: any, field: any): string;
+declare function twoC2pSubstitutionsRefusal(template: any, substitution: any): {
+    code: string;
+    message: any;
+} | null;
+declare function twoC2pKeyUsable(authorization: any): boolean;
+export { TWOC2P_CAPABILITY, TWOC2P_FIELD, TWOC2P_FIELD_AT, TWOC2P_OPERATION, TWOC2P_PSP, TWOC2P_REFUSAL_CODES, TWOC2P_REVIEWED_BUILDS, TWOC2P_SCHEME, encryptTwoC2pCard, substituteTwoC2p, twoC2pBodyVerdict, twoC2pKeyUsable, twoC2pPaymentCarriesCard, twoC2pPaymentTarget, twoC2pRefusalMessage, twoC2pRequestRefusal, twoC2pSubstitutionOf, twoC2pSubstitutionsRefusal };