@agent-cards/sdk 0.21.0 → 0.23.0

package/dist/cse-body.js

@@ -3,6 +3,7 @@
 import { substituteEncryptedFields } from './substitute.js';
 import { substituteMerchantHostedBody } from './merchant-hosted.js';
 import { fiservCapturePinId, isFiservCaptureHost, substituteFiservEnvelope } from './fiserv.js';
+import { substituteVerifoneBody } from './verifone.js';
 /**
  * The cse continuation: the paused body with the vault's ciphertext in place
  * of the dummy blobs. The adapters send it as postData ALONE. Chromium
@@ -25,8 +26,17 @@ import { fiservCapturePinId, isFiservCaptureHost, substituteFiservEnvelope } fro
  * a Fiserv capture host. Every refusal throws before anything is sent.
  */
 export function cseBody(body, replay, url, preparation) {
+    // A Verifone approval is always a prepared one for the profile it pays, and continues only the
+    // leg that profile reviewed, with the device's blob written into the LIVE paused body, which
+    // must still be the body the API checked at create (verifone.ts).
+    if (preparation?.psp === 'verifone' || replay.kind === 'verifone') {
+        if (replay.kind !== 'verifone' || preparation?.psp !== 'verifone' || preparation.merchantProfile !== replay.profile) {
+            throw new Error('Refusing to substitute: the paused request is not the Verifone card request the cardholder approved.');
+        }
+        return substituteVerifoneBody({ url, method: 'POST', body }, replay);
+    }
     if (preparation?.psp === 'fiserv') {
-        if (replay.kind === 'merchant_hosted' || !isFiservCaptureHost(url) || fiservCapturePinId(url, body) !== preparation.merchantProfile) {
+        if (replay.kind !== undefined || !isFiservCaptureHost(url) || fiservCapturePinId(url, body) !== preparation.merchantProfile) {
             throw new Error('Refusing to substitute: the paused request is not a Fiserv capture under the key pin the cardholder approved.');
         }
         return substituteFiservEnvelope(body, replay.substitutions);

package/dist/cybersource-flex.d.ts

@@ -158,6 +158,8 @@ export declare class MicroformFrames {
     /** 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;
+    /** The card Microform whose field documents this attachment recorded, for prepare({ tokenizeBeforePay: true }). */
+    loadedCard(): LoadedCardMicroform;
     /**
      * 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
@@ -173,6 +175,34 @@ export declare class MicroformFrames {
  * 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>;
+/**
+ * What prepare({ tokenizeBeforePay: true }) reads from the page before Pay: the one card Microform
+ * whose fields loaded, its capture context and its fields, or why there is none to read.
+ */
+export type LoadedCardMicroform = {
+    ok: true;
+    captureContext: string;
+    environment: string;
+    microform: {
+        version: string;
+        fields: MicroformField[];
+    };
+} | {
+    ok: false;
+    reason: 'microform_not_loaded' | 'microform_ambiguous' | 'microform_unsupported';
+};
+/**
+ * The card Microform a page loaded, for prepare({ tokenizeBeforePay: true }): every committed card
+ * field-iframe document, grouped by capture context, microform id, version and host. One group of a
+ * reviewed version, with a card number field and at most a security code field, is the checkout the
+ * cardholder's device tokenizes before Pay. No group is `microform_not_loaded` (prepare once the card
+ * fields show), two or more are `microform_ambiguous`, and any other group is `microform_unsupported`.
+ * A check (eCheck) Microform carries no card and is not counted. Reads the frames only; the capture
+ * context is verified by prepareCheckout, the API and the device.
+ */
+export declare function loadedCardMicroform(frames: Iterable<MicroformFrame>): LoadedCardMicroform;
+/** The Playwright adapter's read: every frame URL on the page (Playwright keeps the fragment in frame.url()). */
+export declare function loadedCardMicroformFromUrls(urls: Iterable<string | undefined>): LoadedCardMicroform;
 /**
  * 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

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

@@ -89,4 +89,30 @@ declare function transientTokenFacts(status: any, body: any, verified: any, card
 }>;
 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 };
+declare var CYBERSOURCE_FLEX_PRESEAL_TRIGGER: string;
+declare function admitCybersourceFlexPreparation(prepared: any, { crypto, now }?: {}): Promise<Readonly<{
+    context: 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;
+    }>;
+    fields: readonly string[];
+}>>;
+declare function sameCybersourceFlexPreparation(prepared: any, request: any): boolean;
+export { CYBERSOURCE_FLEX_CAPTURE_CONTEXT_MAX_LENGTH, CYBERSOURCE_FLEX_CONTENT_TYPE, CYBERSOURCE_FLEX_PRESEAL_TRIGGER, 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, admitCybersourceFlexPreparation, assertCybersourceFlexTemplate, buildCardPlaintext, cybersourceFlexEnvironment, flexHostEnvironment as cybersourceFlexHostEnvironment, cybersourceFlexPreparationUrl, cybersourceFlexRefusalCode, cybersourceFlexTemplateKid, detectCardTypes, isCybersourceFlexMediaType, isCybersourceFlexRequest, isCybersourceFlexTemplateBody, isCybersourceFlexTokenShape, isPreparedCybersourceFlexRequest, isVerifiedCaptureContext, parseMicroformFragment, sameCybersourceFlexPreparation, sealForContext, transientTokenFacts, transientTokenSigned, verifyCaptureContext };

package/dist/cybersource-flex.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: a2260c2d905a5cd4ef148ab8a79e90fb2f9f6790d9efba06e95ed35f8bea2755
+// artifact-sha256: a2baaac410b5aaa629b3d5031136f88645c7b45c67c3bbc154cad72de216a04e
 // src/cybersource-flex-rules.js
 var CYBERSOURCE_FLEX_RULES_SOURCE = Object.freeze({ version: "2.12.1", sha256: "8429ebae83e9745cd53ad8ff0d9ba69bee0087c1435ed0695a25444bed418327" });
 var CYBERSOURCE_FLEX_RULES = [
@@ -686,4 +686,44 @@ function iframeHeaders(headers) {
 function isPreparedCybersourceFlexRequest(url, method, body, environment, headers) {
     return (environment === "production" || environment === "sandbox") && method === "POST" && cybersourceFlexEnvironment(url) === environment && iframeHeaders(headers) && isCybersourceFlexTemplateBody(body);
 }
-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 };
+var CYBERSOURCE_FLEX_PRESEAL_TRIGGER = "number";
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function preparedLayout(microform) {
+    if (!isRecord(microform) || typeof microform.version !== "string" || !CYBERSOURCE_FLEX_REVIEWED_IFRAME_VERSIONS.includes(microform.version)) {
+        refuse("microform_version", "this payment's card field is not a Microform version this device can rebuild.");
+    }
+    if (Object.keys(microform).some((key) => key !== "version" && key !== "fields")) {
+        refuse("fields", "the Microform fields this payment loaded are not a card number field and an optional security code field.");
+    }
+    fieldSet(microform.fields, CYBERSOURCE_FLEX_PRESEAL_TRIGGER);
+    return Object.freeze(FIELD_TYPES.filter((field) => microform.fields.includes(field)));
+}
+async function admitCybersourceFlexPreparation(prepared, { crypto, now } = {}) {
+    if (!isRecord(prepared))
+        refuse("request", "malformed checkout preparation.");
+    const fields = preparedLayout(prepared.microform);
+    const { environment } = prepared;
+    if (environment !== "production" && environment !== "sandbox") {
+        refuse("environment_mismatch", "the preparation names no CyberSource environment.");
+    }
+    const context = await verifyCaptureContext(prepared.capture_context, { crypto, now });
+    if (context.environment !== environment || context.url !== CYBERSOURCE_FLEX_TOKENS_URLS[environment]) {
+        refuse("environment_mismatch", "the CyberSource test and live environments are mixed in this payment.");
+    }
+    return Object.freeze({ context, fields });
+}
+function sameCybersourceFlexPreparation(prepared, request) {
+    if (!isRecord(prepared) || !isRecord(request) || !isRecord(prepared.microform) || !isRecord(request.microform))
+        return false;
+    const context = prepared.capture_context;
+    if (typeof context !== "string" || context.length < 1 || context.length > CAPTURE_CONTEXT_MAX_LENGTH || request.capture_context !== context)
+        return false;
+    const one = prepared.microform;
+    const two = request.microform;
+    if (typeof one.version !== "string" || one.version !== two.version || !Array.isArray(one.fields) || !Array.isArray(two.fields))
+        return false;
+    const mine = new Set(one.fields);
+    const theirs = new Set(two.fields);
+    return mine.size === one.fields.length && theirs.size === two.fields.length && mine.size === theirs.size && [...mine].every((field) => theirs.has(field));
+}
+export { CYBERSOURCE_FLEX_CAPTURE_CONTEXT_MAX_LENGTH, CYBERSOURCE_FLEX_CONTENT_TYPE, CYBERSOURCE_FLEX_PRESEAL_TRIGGER, 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, admitCybersourceFlexPreparation, assertCybersourceFlexTemplate, buildCardPlaintext, cybersourceFlexEnvironment, flexHostEnvironment as cybersourceFlexHostEnvironment, cybersourceFlexPreparationUrl, cybersourceFlexRefusalCode, cybersourceFlexTemplateKid, detectCardTypes, isCybersourceFlexMediaType, isCybersourceFlexRequest, isCybersourceFlexTemplateBody, isCybersourceFlexTokenShape, isPreparedCybersourceFlexRequest, isVerifiedCaptureContext, parseMicroformFragment, sameCybersourceFlexPreparation, sealForContext, transientTokenFacts, transientTokenSigned, verifyCaptureContext };

package/dist/cybersource-flex.js

@@ -222,6 +222,10 @@ export class MicroformFrames {
         if (typeof frameId === 'string')
             this.frames.delete(frameId);
     }
+    /** The card Microform whose field documents this attachment recorded, for prepare({ tokenizeBeforePay: true }). */
+    loadedCard() {
+        return loadedCardMicroform(this.frames.values());
+    }
     /**
      * 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
@@ -251,6 +255,48 @@ export function judgeMicroformFrameUrls(request, issuingUrl, frameUrls, contexts
     }
     return judgeMicroformRequest(request, issuingUrl === undefined ? undefined : frameOf(issuingUrl), frames, contexts);
 }
+/**
+ * The card Microform a page loaded, for prepare({ tokenizeBeforePay: true }): every committed card
+ * field-iframe document, grouped by capture context, microform id, version and host. One group of a
+ * reviewed version, with a card number field and at most a security code field, is the checkout the
+ * cardholder's device tokenizes before Pay. No group is `microform_not_loaded` (prepare once the card
+ * fields show), two or more are `microform_ambiguous`, and any other group is `microform_unsupported`.
+ * A check (eCheck) Microform carries no card and is not counted. Reads the frames only; the capture
+ * context is verified by prepareCheckout, the API and the device.
+ */
+export function loadedCardMicroform(frames) {
+    const groups = new Map();
+    for (const frame of frames) {
+        if (frame.microformType !== 'card')
+            continue;
+        const key = JSON.stringify([frame.captureContext, frame.microformId, frame.version, frame.environment]);
+        const group = groups.get(key);
+        if (group)
+            group.types.add(frame.fieldType);
+        else
+            groups.set(key, { frame, types: new Set([frame.fieldType]) });
+    }
+    if (groups.size === 0)
+        return { ok: false, reason: 'microform_not_loaded' };
+    if (groups.size > 1)
+        return { ok: false, reason: 'microform_ambiguous' };
+    const [{ frame, types }] = [...groups.values()];
+    if (!frame.reviewed || !types.has('number') || [...types].some((type) => !MICROFORM_FIELDS.includes(type))) {
+        return { ok: false, reason: 'microform_unsupported' };
+    }
+    return { ok: true, captureContext: frame.captureContext, environment: frame.environment,
+        microform: { version: frame.version, fields: MICROFORM_FIELDS.filter((field) => types.has(field)) } };
+}
+/** The Playwright adapter's read: every frame URL on the page (Playwright keeps the fragment in frame.url()). */
+export function loadedCardMicroformFromUrls(urls) {
+    const frames = [];
+    for (const url of urls) {
+        const frame = frameOf(url);
+        if (frame)
+            frames.push(frame);
+    }
+    return loadedCardMicroform(frames);
+}
 /**
  * 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

package/dist/datatrans.d.ts

@@ -0,0 +1,96 @@
+import { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_INVALID_REQUEST } from './datatrans.generated.js';
+import type { ReplayResponse } from './client.js';
+export declare const DATATRANS_PSP = "datatrans";
+/** The dark-launch capability the API serves the datatrans recognizer behind. */
+export declare const DATATRANS_CAPABILITY = "datatrans_secure_fields_tokenize";
+/**
+ * Why the SDK refuses a Datatrans card post before anything is claimed, created or prompted. The
+ * API answers the same two codes at create, so a refusal here only saves the round trip:
+ *   - `invalid_datatrans_request`: not a sound Secure Fields TOKENIZE card post. That covers
+ *     another mode, a payment or 3-D Secure post (`transactionId`, `3D`, `dccSelected`), a key
+ *     field.js never sends, a URL variant (a query, a case or dot spelling) or a content type that
+ *     is not jQuery's form type. The cardholder's device could never fill it.
+ *   - `datatrans_card_on_file_refused`: a sound post that asks PCI Proxy to keep the card on file
+ *     (usage=REGISTRATION: a reusable alias plus a network token, so the merchant could charge the
+ *     card again later), while the card-on-file policy the API served refuses that
+ *     (datatransCardOnFilePolicy). British Airways's Nexus checkout sends it for every new card.
+ */
+export type DatatransRefusalReason = typeof DATATRANS_INVALID_REQUEST | typeof DATATRANS_CARD_ON_FILE_REFUSED;
+/** True when the URL's host is one of Datatrans's two pay hosts. */
+export declare function isDatatransHost(url: string): boolean;
+/**
+ * The card-on-file policy this build applies to a Datatrans card post: the one the API served with
+ * the datatrans recognizer (Recognizer.cardOnFile, VaultClient.cardOnFilePolicy) when payment-core
+ * defines it (`refuse`, `disclose`, `agentcard_single_use`), and `refuse` for anything else, an entry
+ * that names none included. The decision is payment-core's DATATRANS_REGISTRATION_POLICY, which the
+ * API reads each time it serves the catalog and again at create, so a change to that one line
+ * reaches every build already published at its next syncRegistry(), with no SDK release.
+ */
+export declare function datatransCardOnFilePolicy(served: unknown): string;
+/**
+ * The pause decision for a POST the registry recognized on a Datatrans pay host, by payment-core's
+ * classifyDatatransRequest under the card-on-file policy the API served (datatransCardOnFilePolicy):
+ *   'card'  the exact card URL with jQuery's form type and a sound TOKENIZE card body: it pauses. A
+ *           usage=REGISTRATION post is one too once the served policy allows card on file, and the
+ *           API and the cardholder's device then apply that policy;
+ *   a DatatransRefusalReason: it is refused in the browser;
+ *   null    no card in the body (a wallet, bank-account or CVV-only post) or not the card path:
+ *           the SDK's ordinary handling decides, and such a post continues untouched.
+ */
+export declare function datatransPauseDecision(request: {
+    url: string;
+    headers: Record<string, string>;
+    body: string | null;
+}, servedPolicy?: unknown): 'card' | DatatransRefusalReason | null;
+/**
+ * How long an approved Datatrans answer is replayed to its own frame: the token's own lifetime
+ * (PCI Proxy keeps a tokenization readable for 30 minutes). Past it the stored transactionId names a
+ * token the merchant can no longer read, so a later post is a new question.
+ */
+export declare const DATATRANS_REPEAT_WINDOW_MS: number;
+/**
+ * How long a stored answer waits for its form's next post. British Airways re-submits while the agent
+ * finishes the card form, right after the approved answer. A form that posts nothing for this long has
+ * moved on: the order was placed or abandoned, which the SDK cannot tell apart without reconcile(). Its
+ * next post is a new approval. Each answered re-submit restarts the wait, and the token's lifetime
+ * still ends every answer.
+ */
+export declare const DATATRANS_REPEAT_IDLE_MS: number;
+/** A stored answer handed to a repeat, with the approval it came from. */
+export interface DatatransRepeatAnswer {
+    authorizationId: string;
+    response: {
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    };
+}
+/**
+ * The approved Datatrans answers one attachment handed to a card post, per frame. `frame` is the
+ * adapter's identity for the request's frame (the CDP frameId, the Playwright Frame); a request
+ * whose frame is unknown is never remembered and never answered. Only an answer payment-core reads
+ * as approved ({transactionId, cardInfo}) is kept: an error answer leaves the next post a new
+ * question, so the page can try again.
+ */
+export declare class DatatransRepeats {
+    private readonly windowMs;
+    private readonly now;
+    private readonly idleMs;
+    private remembered;
+    constructor(windowMs?: number, now?: () => number, idleMs?: number);
+    /**
+     * Keep the answer a token replay handed to this card post, when Datatrans 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: unknown, url: string, body: string | null, replay: ReplayResponse): void;
+    /**
+     * The stored answer for a repeat of an answered card post from the same frame, 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. An answer whose form stayed quiet past the idle bound is dropped too, and
+     * handing one out restarts that bound.
+     */
+    answerFor(frame: unknown, url: string, body: string | null, authorizationId: string | null): DatatransRepeatAnswer | null;
+    private prune;
+}

package/dist/datatrans.generated.d.ts

@@ -0,0 +1,64 @@
+declare var DATATRANS_HOSTS: readonly string[];
+declare var DATATRANS_TOKENIZE_PATH: string;
+declare var DATATRANS_REFUSAL_REASONS: readonly string[];
+declare var DATATRANS_INVALID_REQUEST: string;
+declare var DATATRANS_CARD_ON_FILE_REFUSED: string;
+declare var DATATRANS_REGISTRATION_POLICIES: readonly string[];
+declare var DATATRANS_REGISTRATION_POLICY: string;
+declare var DATATRANS_REVIEWED_MERCHANT_IDS: Readonly<{
+    "pay.datatrans.com": readonly never[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>;
+declare var DATATRANS_PAYMENT_METHODS: readonly string[];
+declare var DATATRANS_TEST_PANS: readonly string[];
+declare function encodeDatatransFormValue(value: any): string;
+declare function parseDatatransForm(body: any): {
+    key: string;
+    value: string;
+    rawKey: string;
+    raw: string;
+}[] | null;
+declare function serializeDatatransForm(pairs: any): any;
+declare function isDatatransTokenizeUrl(url: any, method?: string): boolean;
+declare function datatransRegistrationRefusal(usage: any, card: any, policy?: string): "card_on_file" | null;
+declare function datatransCardOnFileDisclosure(body: any, policy?: string): boolean;
+declare function datatransBodyRefusal(body: any, card: any, policy?: string): "unsupported" | "card_on_file" | null;
+declare function datatransMerchantId(body: any): string | null | undefined;
+declare function classifyDatatransRequest(url: any, method: any, body: any, headers: any, policy?: string): "card" | "unsupported" | "card_on_file" | null;
+declare function datatransTokenizeRefusal(request: any, card: any, policy?: string): "unsupported" | "card_on_file" | null;
+declare function isDatatransTokenizeRequest(request: any, card: any): boolean;
+declare function datatransMerchantRefusal(url: any, body: any, merchants?: Readonly<{
+    "pay.datatrans.com": readonly never[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>): "unregistered_merchant" | null;
+declare function datatransDeviceRefusal(request: any, card: any, policy?: string, merchants?: Readonly<{
+    "pay.datatrans.com": readonly never[];
+    "pay.sandbox.datatrans.com": readonly string[];
+}>): "unsupported" | "card_on_file" | "brand_mismatch" | "unregistered_merchant" | null;
+declare function datatransRefusalMessage(reason: any): string;
+declare function datatransCardBrand(number: any): "VIS" | "ECA" | "AMX" | null;
+declare function datatransBrandRefusal(body: any, card: any): "unsupported" | "brand_mismatch" | null;
+declare function injectDatatransCard(body: any, card: any, policy?: string): {
+    body: string;
+    where: string[];
+};
+declare function datatransErrorCode(message: any): string | RegExp;
+declare function datatransResponseOutcome(status: any, body: any, card: any): {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+} | {
+    outcome: string;
+    code: string | RegExp;
+    reason?: undefined;
+} | {
+    outcome: string;
+    reason?: undefined;
+    code?: undefined;
+};
+declare function sanitizeDatatransTokenResponse(body: any): string;
+declare function datatransFacts(status: any, body: any): {
+    outcome: string;
+    refusalCode: string | RegExp | null | undefined;
+};
+export { DATATRANS_CARD_ON_FILE_REFUSED, DATATRANS_HOSTS, DATATRANS_INVALID_REQUEST, DATATRANS_PAYMENT_METHODS, DATATRANS_REFUSAL_REASONS, DATATRANS_REGISTRATION_POLICIES, DATATRANS_REGISTRATION_POLICY, DATATRANS_REVIEWED_MERCHANT_IDS, DATATRANS_TEST_PANS, DATATRANS_TOKENIZE_PATH, classifyDatatransRequest, datatransBodyRefusal, datatransBrandRefusal, datatransCardBrand, datatransCardOnFileDisclosure, datatransDeviceRefusal, datatransErrorCode, datatransFacts, datatransMerchantId, datatransMerchantRefusal, datatransRefusalMessage, datatransRegistrationRefusal, datatransResponseOutcome, datatransTokenizeRefusal, encodeDatatransFormValue, injectDatatransCard, isDatatransTokenizeRequest, isDatatransTokenizeUrl, parseDatatransForm, sanitizeDatatransTokenResponse, serializeDatatransForm };