@agent-cards/sdk 0.20.0 → 0.21.0

package/dist/client.js

@@ -12,6 +12,9 @@ import { BuyModule } from './buy.js';
 import { Languages } from './languages.js';
 import { RequestRegistry } from './requests.js';
 import { AgentcardError } from './voice-types.js';
+import { GMO_CAPABILITY, GMO_PSP, gmoTokenAnswer } from './gmo.js';
+import { isCybersourceFlexTokenShape } from './cybersource-flex.generated.js';
+import { CYBERSOURCE_FLEX_CAPABILITY, CYBERSOURCE_FLEX_PSP, validCybersourceFlexSidecar } from './cybersource-flex.js';
 /**
  * The modes this SDK can finish. Asked for on syncRegistry (the API serves
  * only recognizers in these modes, so a request this build cannot complete
@@ -31,14 +34,34 @@ export const SUPPORTED_REGISTRY_FEATURES = ['card_fields', 'checkout_sessions'];
 /**
  * Dark-launch capabilities this build can finish. Sent on syncRegistry as
  * ?capabilities= so the API also serves the recognizers gated behind one of
- * these. `fiserv_card_capture`: Fiserv Commerce Hub's Secure Data Capture card
+ * these, and only to an org Agentcard enabled for the processor.
+ * `fiserv_card_capture`: Fiserv Commerce Hub's Secure Data Capture card
  * capture, which this build pauses and pays only through a prepared checkout
  * (pre-claim.ts, fiserv.ts). The API serves Fiserv's recognizer only to a build
  * that lists it and only for a company Agentcard turned Fiserv on for, so an older
  * SDK never pauses a capture it cannot finish and no SDK pauses one for a company
  * Fiserv is off for; the API also refuses a Fiserv payment for every such company.
+ * `gmo_shared_pk`: GMO token v2's getToken on the shared-key path, which this
+ * build judges before it pauses (gmo.ts) and pays only for the amount the
+ * agent passes. A gated recognizer never sits in BUILTIN_REGISTRY, so it is
+ * paused only after a sync.
+ * `capture_context`: CyberSource Flex Microform, whose create carries the capture
+ * context this build reads from the card field iframe (cybersource-flex.ts); the API
+ * serves Flex's recognizer the same way, only for a company Agentcard turned it on for.
+ * A gated recognizer is never in BUILTIN_REGISTRY, so a build reaches it only through a
+ * sync that declares its capability.
  */
-export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture'];
+export const SUPPORTED_CAPABILITIES = ['fiserv_card_capture', GMO_CAPABILITY, CYBERSOURCE_FLEX_CAPABILITY];
+/**
+ * Processors whose paused request names no amount at all, so the pair the
+ * agent passes is the amount the cardholder approves: authorize() refuses one
+ * without it (AmountRequiredError), and the API answers 400 amount_required
+ * for the same case. GMO's card token request carries none: the merchant's
+ * server charges the token later, for the amount it decides.
+ */
+const AGENT_AMOUNT_PROCESSORS = [GMO_PSP];
+/** How AmountRequiredError names a processor. */
+const PROCESSOR_NAMES = { [GMO_PSP]: 'GMO' };
 /** An integer in the smallest unit, or a decimal string in normal units with a point; nothing else. */
 export function validAmountInput(amount) {
     if (typeof amount === 'number')
@@ -78,6 +101,50 @@ export class UnsupportedModeError extends Error {
         this.name = 'UnsupportedModeError';
     }
 }
+/**
+ * The recognizer is gated behind a dark-launch capability this SDK build does not
+ * declare (SUPPORTED_CAPABILITIES), so it cannot send what that processor's create
+ * needs. Thrown locally before any create or prompt, and terminal. A registry the
+ * API served never holds such an entry (it serves a gated one only to a build that
+ * declares it); a hand-built one can.
+ */
+export class UnsupportedCapabilityError extends Error {
+    capability;
+    constructor(capability) {
+        super(`the checkout needs the "${capability}" capability, which this version of @agent-cards/checkout cannot complete; upgrade the SDK.`);
+        this.capability = capability;
+        this.name = 'UnsupportedCapabilityError';
+    }
+}
+/**
+ * placeholderCard() found no stored card to describe (`card_not_found`), the stored card's
+ * network has no documented placeholder number (`brand_unsupported`), or the stored card
+ * carries no usable expiry (`expiry_unknown`). Nothing was created and nothing was charged.
+ */
+export class PlaceholderCardError extends Error {
+    reason;
+    constructor(reason) {
+        super(`no placeholder card: ${reason}`);
+        this.reason = reason;
+        this.name = 'PlaceholderCardError';
+    }
+}
+/**
+ * The placeholder number per network: a documented test card that the pinned Microform
+ * card-type table detects as that network and nothing else. Visa, Mastercard, Amex and JCB
+ * are CyberSource's own test cards (developer.cybersource.com hello-world testing guide).
+ * Discover is not: CyberSource's 6011111111111117 falls in the table's Maestro range, so a
+ * merchant that allows Discover but not Maestro refuses it in the card field itself; Stripe's
+ * documented Discover test card 6011000990139424 is detected as Discover alone. A network
+ * outside this list has no placeholder and placeholderCard() refuses it rather than guess.
+ */
+const PLACEHOLDER_NUMBERS = Object.freeze({
+    visa: '4111111111111111',
+    mastercard: '5555555555554444',
+    amex: '378282246310005',
+    discover: '6011000990139424',
+    jcb: '3566111111111113',
+});
 /**
  * The recognizer says this processor is preparation-required, and no preparation
  * was passed. Its card may be sent only after the cardholder approved a
@@ -94,6 +161,24 @@ export class PreparationRequiredError extends Error {
         this.name = 'PreparationRequiredError';
     }
 }
+/**
+ * The paused request names no amount and none was passed. A GMO card token
+ * request carries no amount (the merchant's server charges the token later),
+ * so the `amount` and `currency` you pass are what the cardholder approves.
+ * Thrown locally before any create or prompt, and terminal: the same request
+ * without an amount fails the same way. The API answers 400 amount_required
+ * for the same case. A page total (`pageAmount`) does not count.
+ */
+export class AmountRequiredError extends Error {
+    psp;
+    code = 'amount_required';
+    constructor(psp) {
+        const processor = PROCESSOR_NAMES[psp] ?? psp;
+        super(`A ${processor} payment request names no amount, so pass amount and currency: that is the amount the cardholder approves. Nothing was created and nothing was charged.`);
+        this.psp = psp;
+        this.name = 'AmountRequiredError';
+    }
+}
 export class ApprovalTimeoutError extends Error {
     constructor(ms) { super(`user did not approve within ${ms}ms`); this.name = 'ApprovalTimeoutError'; }
 }
@@ -688,9 +773,14 @@ export class VaultClient {
         let raw;
         // ?capabilities= is the dark-launch half of the same negotiation: a
         // processor gated behind a capability is served only when this build lists
-        // it. This build lists fiserv_card_capture, so it arms Fiserv's card capture
-        // for a company Agentcard turned Fiserv on for; an older build, and every
-        // other company's, never sees that recognizer.
+        // it (SUPPORTED_CAPABILITIES: fiserv_card_capture, gmo_shared_pk,
+        // capture_context) and the caller's company is one Agentcard turned that
+        // processor on for, so this build arms Fiserv's card capture, GMO's getToken
+        // and CyberSource Flex's card fields only for such a company, and an older
+        // build never receives a recognizer it cannot judge. Every other org's
+        // registry never recognizes a Flex host, so its Microform requests go
+        // through untouched; the create checks the org again (403
+        // processor_unavailable).
         const capabilities = SUPPORTED_CAPABILITIES.length ? `&capabilities=${SUPPORTED_CAPABILITIES.join(',')}` : '';
         // merchant_profiles=1 asks for the reviewed Adyen merchant profiles too, each
         // as a `{ merchant_profile }` entry after the recognizers; an API that
@@ -786,6 +876,39 @@ export class VaultClient {
         const registry = this.mergedRegistry();
         return this.sandbox ? [...deriveCardUrlPatterns(registry), ...LOOPBACK_URL_PATTERNS] : deriveCardUrlPatterns(registry);
     }
+    /**
+     * What to type into a checkout so the page's own card facts match the stored card that
+     * pays (see PlaceholderCard): read from GET /api/v2/vault_cards, which lists each stored card's
+     * network and expiry. `cardId` names the stored card; omitted, the user's most recently added
+     * card. Pin the returned `cardId` on the attachment or authorize(), so the approval page
+     * preselects that card: without a pin the page preselects its own choice (its recommended
+     * card, or the first card the cardholder's device can open), which can be another card. After
+     * prepare(), pass the prepared checkout's `cardId`, the card the cardholder already approved.
+     * The facts hold only while the cardholder pays with that card. Throws PlaceholderCardError
+     * when there is no such card, its network has no placeholder, or it carries no expiry.
+     */
+    async placeholderCard(input) {
+        if (!input || typeof input.user !== 'string' || !input.user)
+            throw new Error('placeholderCard needs the user whose stored card will pay.');
+        // The card list lives under /api/v2 only: the API aliases /v2/checkout alone without the prefix.
+        const list = await this.get(`/api/v2/vault_cards?user_id=${encodeURIComponent(input.user)}`, input.signal);
+        const cards = Array.isArray(list?.data) ? list.data : [];
+        const card = (input.cardId === undefined ? cards[0] : cards.find((entry) => entry?.id === input.cardId));
+        if (!card || typeof card !== 'object' || typeof card.id !== 'string' || !card.id)
+            throw new PlaceholderCardError('card_not_found');
+        const brand = typeof card.brand === 'string' ? card.brand.toLowerCase() : '';
+        const number = Object.prototype.hasOwnProperty.call(PLACEHOLDER_NUMBERS, brand) ? PLACEHOLDER_NUMBERS[brand] : undefined;
+        if (!number)
+            throw new PlaceholderCardError('brand_unsupported');
+        const month = card.expiry_month, year = card.expiry_year;
+        if (!Number.isSafeInteger(month) || month < 1 || month > 12
+            || !Number.isSafeInteger(year) || year < 2000 || year > 2099)
+            throw new PlaceholderCardError('expiry_unknown');
+        return Object.freeze({
+            cardId: card.id, brand, number, securityCode: brand === 'amex' ? '1234' : '123',
+            expiryMonth: String(month).padStart(2, '0'), expiryYear: String(year),
+        });
+    }
     /** Wait for real device approval before the caller starts native tokenization. */
     async prepareCheckout(input) {
         input = { ...input };
@@ -1069,6 +1192,22 @@ export class VaultClient {
             throw new CardEncryptedError(rec.psp);
         if (!SUPPORTED_MODES.includes(mode))
             throw new UnsupportedModeError(mode);
+        // A dark-launch recognizer names the capability its create needs. A build that does not
+        // declare it cannot send what that create carries, so it refuses here, before any create;
+        // a registry the API served never holds such an entry.
+        if (rec.capability !== undefined && !SUPPORTED_CAPABILITIES.includes(rec.capability))
+            throw new UnsupportedCapabilityError(rec.capability);
+        // CyberSource Flex: the capture context and the Microform fields ride on the request (the
+        // adapters read both from the card field iframe) and the API verifies them before anything
+        // exists. They belong to a Flex request and nothing else, as the API holds them.
+        const flex = rec.psp === CYBERSOURCE_FLEX_PSP;
+        if (!flex && (input.request.capture_context !== undefined || input.request.microform !== undefined)) {
+            throw new Error('request.capture_context and request.microform belong to a CyberSource Flex card request.');
+        }
+        if (flex && !validCybersourceFlexSidecar(input.request.capture_context, input.request.microform)) {
+            throw new Error('A CyberSource Flex card request carries the capture context its card field iframe was loaded with (request.capture_context) '
+                + 'and the Microform fields that loaded (request.microform); attachToCdp and attachToPlaywright read both.');
+        }
         // Say no rather than coerce. isCardRequest only ever pauses a POST, and the
         // service stores the replay template with method 'POST' hardcoded — so a
         // caller handing in a PUT or GET would get it silently rewritten and the
@@ -1090,6 +1229,12 @@ export class VaultClient {
         if (hasAmount && !validAmountInput(input.amount)) {
             throw new Error('amount is an integer in the currency\'s smallest unit (2306 for $23.06), or a decimal string in normal units ("23.06").');
         }
+        // A processor whose request names no amount (AGENT_AMOUNT_PROCESSORS) is
+        // paid only for the pair passed here: it is all the approval can show.
+        // Refused before any create or prompt; the API refuses the same create as
+        // amount_required.
+        if (!hasAmount && AGENT_AMOUNT_PROCESSORS.includes(rec.psp))
+            throw new AmountRequiredError(rec.psp);
         const timeoutMs = input.timeoutMs ?? 15 * 60_000;
         if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
             throw new Error('timeoutMs must be a positive integer no larger than 2147483647.');
@@ -1135,6 +1280,11 @@ export class VaultClient {
                     ...(checkoutContext ? { [STRIPE_CHECKOUT_CONTEXT_HEADER]: encodeStripeCheckoutContext(checkoutContext) } : {}) },
                 body: input.request.body,
                 ...(mercadoContext ? { mercado_checkout: mercadoContext } : {}),
+                ...(flex ? {
+                    capture_context: input.request.capture_context,
+                    microform: { version: input.request.microform.version, fields: [...input.request.microform.fields],
+                        ...(input.request.microform.trigger ? { trigger: input.request.microform.trigger } : {}) },
+                } : {}),
             },
         };
         try {
@@ -1334,6 +1484,12 @@ export class VaultClient {
                         || typeof response.body !== 'string' || !response.headers || typeof response.headers !== 'object' || Array.isArray(response.headers)) {
                         throw new PaymentOutcomeUnknownError(authorizationId, 'approved_response_malformed');
                     }
+                    // A Flex approval answers the card field with the transient token CyberSource signed for
+                    // the device's sealed card, which the device checked before it approved. Anything else
+                    // is not an answer to hand the field iframe: the device may already have sent the card.
+                    if (flex && (response.status < 200 || response.status > 299 || !isCybersourceFlexTokenShape(response.body))) {
+                        throw new PaymentOutcomeUnknownError(authorizationId, 'cybersource_flex_token_unconfirmed');
+                    }
                     if (shopOrder) {
                         let receipt;
                         try {
@@ -1358,6 +1514,17 @@ export class VaultClient {
                         response.body = JSON.stringify(receipt);
                         response.headers = { 'content-type': 'application/json' };
                     }
+                    if (rec.psp === GMO_PSP) {
+                        // GMO's answer enters the page only as one clean single-use token under a JSON
+                        // content type (gmo.ts gmoTokenAnswer). Anything else is never handed over; the
+                        // card may have left the device, so the outcome is unknown rather than declined.
+                        const answer = gmoTokenAnswer(response.status, response.body);
+                        if (!answer)
+                            throw new PaymentOutcomeUnknownError(authorizationId, 'gmo_token_unconfirmed');
+                        response.status = answer.status;
+                        response.headers = answer.headers;
+                        response.body = answer.body;
+                    }
                     let processorContext;
                     if (mercadoContext) {
                         try {

package/dist/cybersource-flex.d.ts

@@ -0,0 +1,183 @@
+/** The processor id, as the registry and the API name it. */
+export declare const CYBERSOURCE_FLEX_PSP = "cybersource_flex";
+/**
+ * The dark-launch capability the Flex recognizer names: the capture-context sidecar a create
+ * must carry. syncRegistry declares it (SUPPORTED_CAPABILITIES), because this build reads the
+ * context and sends it; the API serves the recognizer only to a client that does.
+ */
+export declare const CYBERSOURCE_FLEX_CAPABILITY = "capture_context";
+/** The Microform v2 card fields the cardholder's device can rebuild. */
+export type MicroformField = 'number' | 'securityCode';
+/**
+ * The Microform fields of one payment, as the create carries them: the field iframe's version,
+ * the fields that loaded (the number field always, the security code field when the merchant
+ * created it), and the field whose iframe sent this request. The device rebuilds the iframe's
+ * exact plaintext from them, and the triggering field's data comes first in it.
+ */
+export interface MicroformSidecar {
+    version: string;
+    fields: MicroformField[];
+    trigger: MicroformField;
+}
+/** request.capture_context and request.microform on the create. */
+export interface CybersourceFlexSidecar {
+    /** The capture context, byte for byte as the field iframe's URL fragment carries it. */
+    capture_context: string;
+    microform: MicroformSidecar;
+}
+/** A Flex card request the claim flow may take over. */
+export interface CybersourceFlexPause {
+    sidecar: CybersourceFlexSidecar;
+    /**
+     * The request's shape for the retry rule (cdp.ts sameCheckoutRequest): microform type, fields,
+     * the context's key id and the verified capture context itself. Every createToken seals a fresh
+     * JWE, so the body itself never repeats; a retry under the same context and fields carries this
+     * same shape, and a field reloaded under any other context never reuses the approval, even one
+     * whose key id is the same.
+     */
+    shape: string;
+}
+/**
+ * Why a Flex card request is not one this build can pay; reported on the unsupported_checkout
+ * event. Each is a fact about the page that its next request repeats: a request that is not a
+ * Microform card field's (including one from a frame this attachment read and found to be no
+ * Microform field), an unreviewed field version, or fields the device cannot rebuild.
+ */
+export type MicroformUnsupportedReason = 'microform_request_unrecognized' | 'microform_version_unreviewed' | 'microform_fields_unsupported';
+/**
+ * Why this one request is refused while the next may pass; reported on the blocked event.
+ * `microform_frame_unread`: the frame that sent it could not be read (a missed event, a frame
+ * tree read that failed or timed out), which the page's next request may not repeat.
+ */
+export type CybersourceFlexRefusal = 'capture_context_invalid' | 'capture_context_mismatch' | 'request_body_unreadable' | 'microform_frame_unread';
+export type CybersourceFlexDecision = {
+    kind: 'pause';
+    flex: CybersourceFlexPause;
+} | {
+    kind: 'continue';
+} | {
+    kind: 'unsupported';
+    reason: MicroformUnsupportedReason;
+} | {
+    kind: 'refuse';
+    reason: CybersourceFlexRefusal;
+    cause?: string;
+};
+/** The paused request, as the pre-claim gates see it. */
+export interface FlexRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string | null;
+}
+/** An https URL on flex.cybersource.com or testflex.cybersource.com, with no port or credentials. */
+export declare function isCybersourceFlexHost(url: string): boolean;
+/**
+ * How an adapter fails a card request it will not let through: a CyberSource Flex request as a
+ * network error (Playwright 'failed', CDP 'Failed', net::ERR_FAILED), every other request as an
+ * abort (net::ERR_ABORTED). Microform 2.12.1's field reports a failed request to the merchant's page
+ * at once (createToken's callback gets CREATE_TOKEN_XHR_ERROR), so the page runs its own error path:
+ * a message, a retry under the same capture context, or GetPay's reload under a new one. It never
+ * reports an aborted request, so after a refusal or a decline the page's createToken would wait with
+ * no answer. Both were observed with the real field on CyberSource's sandbox.
+ */
+export declare function refusedRequestFailure(url: string): 'failed' | 'aborted';
+/** A Microform field iframe's URL, read: payment-core's parseMicroformFragment. */
+type MicroformFrame = {
+    environment: string;
+    version: string;
+    reviewed: boolean;
+    microformType: string;
+    microformId: string | null;
+    fieldType: string;
+    captureContext: string;
+};
+type VerifiedContext = {
+    url: string;
+    environment: string;
+    exp: number;
+    jwk: {
+        kid: string;
+    };
+};
+type Verification = {
+    ok: true;
+    context: VerifiedContext;
+} | {
+    ok: false;
+    cause: string;
+};
+/**
+ * Each capture context verified once, offline, against the keys payment-core pins, and
+ * remembered for the attachment. The adapters start a context's check when its field iframe
+ * loads, so by the time the page sends its card the answer is usually settled and the pause
+ * stays synchronous. Bounded: the oldest context is dropped past 32.
+ */
+export declare class CaptureContexts {
+    private readonly entries;
+    verify(jwt: string): Verification | Promise<Verification>;
+    /** Start the check of a card field iframe's capture context from the frame's URL, when it is one. */
+    warm(url: string | undefined): void;
+}
+/**
+ * Judge one POST to a Flex host, given the frame that sent it and every Microform frame this
+ * attachment knows. `issuing` is that frame read as a Microform field: `undefined` when its URL
+ * could not be read at all, `null` when it was read and is no Microform v2 field (the merchant's
+ * own page or frame, which is where Flex API direct traffic comes from). In order:
+ *   1. a check (eCheck) Microform: continue, it carries no card;
+ *   2. a body the adapter could not read: refuse this request;
+ *   3. not a field iframe's sealed card (application/jwt, a Microform JWE, the exact tokens
+ *      URL): unsupported, Microform v0.x and Flex API direct post here too;
+ *   4. a frame that could not be read: refuse this request, since the read can fail for a
+ *      reason the page's next request does not repeat (a missed event, a slow frame tree read);
+ *   5. a frame read and found to be no Microform field, an unreviewed version, or fields the
+ *      device cannot rebuild: unsupported, as the page's next request repeats each of them;
+ *   6. a capture context that does not verify, has expired, names another URL or host, or did
+ *      not seal this body: refuse this request;
+ *   7. otherwise pause, with the sidecar the create carries.
+ * Returns synchronously when the context's verification already settled.
+ */
+export declare function judgeMicroformRequest(request: FlexRequest, issuing: MicroformFrame | null | undefined, frames: Iterable<MicroformFrame>, contexts: CaptureContexts): CybersourceFlexDecision | Promise<CybersourceFlexDecision>;
+/**
+ * The CDP adapter's record of Microform field iframes, keyed by frame id (an out-of-process
+ * iframe's target id is its frame id). Fed only from CDP sources that report a document the
+ * frame COMMITTED, with its fragment: Page.frameNavigated (the child's own session for an
+ * out-of-process iframe, the parent's for an in-process one), the iframe target's url on
+ * Target.attachedToTarget when the SDK attaches to a form that already rendered, and the
+ * pausing session's Page.getFrameTree as a last read. A document request (Network.
+ * requestWillBeSent, Fetch.requestPaused) is only a hint that warms the context's check: a page
+ * can start a navigation to a genuine field URL in a frame it scripts and stop it before it
+ * commits, and that frame then still runs the page's own document. A frame that navigates
+ * elsewhere or detaches is forgotten. Bounded to the 64 most recent frames.
+ */
+export declare class MicroformFrames {
+    private readonly frames;
+    readonly contexts: CaptureContexts;
+    /** Start the capture context's check from a navigation that has not committed; records nothing. */
+    warm(url: string | undefined): void;
+    /** A frame's committed document URL, fragment included. A URL that is not a field iframe's forgets the frame. */
+    observe(frameId: unknown, url: unknown): void;
+    forget(frameId: unknown): void;
+    /**
+     * Judge a POST the frame `frameId` sent. When that frame is not on record, `reread` reads the
+     * pausing session's frame tree once (recording what it finds) and resolves to the frame's
+     * committed URL, or undefined when the frame was not found or the read failed: a frame read and
+     * found to be no field is judged as such, one never read is refused for this request alone.
+     */
+    judge(request: FlexRequest, frameId: string | undefined, reread?: () => Promise<string | undefined>): CybersourceFlexDecision | Promise<CybersourceFlexDecision>;
+}
+/**
+ * The Playwright adapter's judge: Playwright keeps a frame's fragment in frame.url() (checked in
+ * cybersource-flex-browser.test.mjs) and moves frame.url() only when a navigation commits, so the
+ * issuing frame and its siblings are read at pause time. `issuingUrl` is undefined when the
+ * request's frame could not be read at all.
+ */
+export declare function judgeMicroformFrameUrls(request: FlexRequest, issuingUrl: string | undefined, frameUrls: Iterable<string | undefined>, contexts: CaptureContexts): CybersourceFlexDecision | Promise<CybersourceFlexDecision>;
+/**
+ * Whether a create's sidecar has the shape the API admits (routes/api/v2/checkout.ts
+ * createSchema): a capture context of 1 to 16384 characters, and a Microform version with a
+ * number field, an optional security code field and a trigger among them. authorize() checks
+ * it before any create, so a hand-built request fails locally rather than at the API.
+ */
+export declare function validCybersourceFlexSidecar(captureContext: unknown, microform: unknown): boolean;
+export {};

package/dist/cybersource-flex.generated.d.ts

@@ -0,0 +1,92 @@
+declare var CYBERSOURCE_FLEX_RULES_SOURCE: Readonly<{
+    version: "2.12.1";
+    sha256: "8429ebae83e9745cd53ad8ff0d9ba69bee0087c1435ed0695a25444bed418327";
+}>;
+declare var CybersourceFlexError: {
+    new (reason: any, message: any): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+declare function isVerifiedCaptureContext(value: any): boolean;
+declare function flexHostEnvironment(hostname: any): "production" | "sandbox" | null;
+declare var CYBERSOURCE_FLEX_PSP: string;
+declare var CYBERSOURCE_FLEX_CONTENT_TYPE: string;
+declare var CYBERSOURCE_FLEX_TOKENS_URLS: Readonly<{
+    production: `https://flex.cybersource.com${string}`;
+    sandbox: `https://testflex.cybersource.com${string}`;
+}>;
+declare var CYBERSOURCE_FLEX_CAPTURE_CONTEXT_MAX_LENGTH: number;
+declare var CYBERSOURCE_FLEX_REVIEWED_IFRAME_VERSIONS: readonly string[];
+declare var CYBERSOURCE_FLEX_SIGNING_KEYS: any;
+declare var CYBERSOURCE_FLEX_TEST_PANS: Readonly<Set<string>>;
+declare function verifyCaptureContext(jwt: any, { crypto, now }?: {}): Promise<Readonly<{
+    raw: any;
+    signingKid: any;
+    environment: any;
+    origin: string;
+    path: string;
+    url: string;
+    jwk: Readonly<{
+        kty: "RSA";
+        n: any;
+        e: any;
+        kid: any;
+    }>;
+    modulusBytes: number;
+    index: any;
+    contextType: any;
+    allowedCardNetworks: readonly any[] | null;
+    targetOrigins: readonly any[];
+    iat: any;
+    exp: any;
+}>>;
+declare function cybersourceFlexEnvironment(url: any): "production" | "sandbox" | undefined;
+declare function parseMicroformFragment(rawUrl: any): Readonly<{
+    environment: "production" | "sandbox";
+    version: string;
+    reviewed: boolean;
+    microformType: any;
+    microformId: any;
+    fieldType: any;
+    keyId: string | null;
+    captureContext: any;
+}> | null;
+declare function detectCardTypes(pan: any, allowedCardNetworks: any): {
+    codes: any[];
+    valid: boolean;
+    cards: {
+        code: any;
+        name: any;
+        valid: any;
+    }[];
+    securityCode: {
+        required: boolean;
+        length: any;
+    };
+};
+declare function cybersourceFlexTemplateKid(body: any): any;
+declare function isCybersourceFlexTemplateBody(body: any): boolean;
+declare function isCybersourceFlexMediaType(value: any): boolean;
+declare function isCybersourceFlexRequest(url: any, method: any, body: any, headers: any): boolean;
+declare function assertCybersourceFlexTemplate(body: any, verified: any): void;
+declare function buildCardPlaintext(verified: any, card: any, { fields, trigger, now }?: {
+    trigger?: string | undefined;
+}): string;
+declare function sealForContext(verified: any, plaintext: any, { crypto }?: {}): Promise<string>;
+declare var CYBERSOURCE_FLEX_REFUSAL_REASONS: readonly string[];
+declare function cybersourceFlexRefusalCode(text: any): string | null;
+declare function isCybersourceFlexTokenShape(text: any): boolean;
+declare function transientTokenSigned(status: any, body: any, verified: any, { crypto }?: {}): Promise<{
+    confirmed: boolean;
+    reason: any;
+}>;
+declare function transientTokenFacts(status: any, body: any, verified: any, card: any, { crypto }?: {}): Promise<{
+    confirmed: boolean;
+    reason: any;
+}>;
+declare function cybersourceFlexPreparationUrl(environment: any): any;
+declare function isPreparedCybersourceFlexRequest(url: any, method: any, body: any, environment: any, headers: any): boolean;
+export { CYBERSOURCE_FLEX_CAPTURE_CONTEXT_MAX_LENGTH, CYBERSOURCE_FLEX_CONTENT_TYPE, CYBERSOURCE_FLEX_PSP, CYBERSOURCE_FLEX_REFUSAL_REASONS, CYBERSOURCE_FLEX_REVIEWED_IFRAME_VERSIONS, CYBERSOURCE_FLEX_RULES_SOURCE, CYBERSOURCE_FLEX_SIGNING_KEYS, CYBERSOURCE_FLEX_TEST_PANS, CYBERSOURCE_FLEX_TOKENS_URLS, CybersourceFlexError, assertCybersourceFlexTemplate, buildCardPlaintext, cybersourceFlexEnvironment, flexHostEnvironment as cybersourceFlexHostEnvironment, cybersourceFlexPreparationUrl, cybersourceFlexRefusalCode, cybersourceFlexTemplateKid, detectCardTypes, isCybersourceFlexMediaType, isCybersourceFlexRequest, isCybersourceFlexTemplateBody, isCybersourceFlexTokenShape, isPreparedCybersourceFlexRequest, isVerifiedCaptureContext, parseMicroformFragment, sealForContext, transientTokenFacts, transientTokenSigned, verifyCaptureContext };