@agent-cards/sdk 0.21.0 → 0.22.0

package/dist/stripe-setup.d.ts

@@ -0,0 +1,16 @@
+/** A SetupIntent confirm's path, as Stripe.js sends it. */
+export declare const STRIPE_SETUP_INTENT_CONFIRM: RegExp;
+/**
+ * The page's SetupIntent confirm, paying with `paymentMethod` instead of the
+ * card it carries: every `payment_method_data[...]` field goes (the card, and
+ * the billing details and telemetry Stripe.js sends beside it; the payment
+ * method already carries the billing details of the approved request), and
+ * `payment_method=<id>` takes the place of the first one. Every other field
+ * stays byte for byte as the page wrote it (client_secret, key,
+ * expected_payment_method_type, use_stripe_sdk, return_url, mandate and option
+ * fields). Null, and nothing is rewritten, when the id is not a payment
+ * method's, when a key cannot be decoded, when the body already names another
+ * way to pay (payment_method, source, confirmation_token), or when it carries
+ * no payment_method_data at all.
+ */
+export declare function setupConfirmPayingWith(body: string, paymentMethod: string): string | null;

package/dist/stripe-setup.js

@@ -0,0 +1,61 @@
+// The SetupIntent confirm a Stripe card save continues with, shared by both
+// adapters (cdp.ts claimStripeContinuation). Kept in its own module, outside the
+// package's published entries, so its tests can reach it.
+//
+// A page that creates the payment method first (createPaymentMethod, which the
+// cardholder approves) and then confirms a SetupIntent usually pays with the
+// pm_ it got back: Twilio's Payment Element page with paymentMethodCreation
+// 'manual' does, on basil and v3 Stripe.js (flows harness F12). Some pages send
+// the card again inline instead, as payment_method_data[card][number] in
+// POST /v1/setup_intents/{seti}/confirm: confirmCardSetup with the Card
+// Element after createPaymentMethod does (F12b). The card there is whatever the
+// agent typed; the approved payment method holds the cardholder's card. So that
+// confirm continues paying with the approved payment method instead, once the
+// API allows it.
+/** A SetupIntent confirm's path, as Stripe.js sends it. */
+export const STRIPE_SETUP_INTENT_CONFIRM = /^\/v1\/setup_intents\/seti_[A-Za-z0-9]+\/confirm$/;
+const PAYMENT_METHOD_ID = /^pm_[A-Za-z0-9]{1,250}$/;
+// The other ways a confirm can say what it pays with. A body that already names
+// one is not the shape rewritten here.
+const OTHER_WAYS_TO_PAY = new Set(['payment_method', 'source', 'confirmation_token']);
+/**
+ * The page's SetupIntent confirm, paying with `paymentMethod` instead of the
+ * card it carries: every `payment_method_data[...]` field goes (the card, and
+ * the billing details and telemetry Stripe.js sends beside it; the payment
+ * method already carries the billing details of the approved request), and
+ * `payment_method=<id>` takes the place of the first one. Every other field
+ * stays byte for byte as the page wrote it (client_secret, key,
+ * expected_payment_method_type, use_stripe_sdk, return_url, mandate and option
+ * fields). Null, and nothing is rewritten, when the id is not a payment
+ * method's, when a key cannot be decoded, when the body already names another
+ * way to pay (payment_method, source, confirmation_token), or when it carries
+ * no payment_method_data at all.
+ */
+export function setupConfirmPayingWith(body, paymentMethod) {
+    if (!PAYMENT_METHOD_ID.test(paymentMethod) || typeof body !== 'string' || body === '')
+        return null;
+    const kept = [];
+    let replaced = false;
+    for (const chunk of body.split('&')) {
+        if (chunk === '')
+            continue;
+        const eq = chunk.indexOf('=');
+        let key;
+        try {
+            key = decodeURIComponent((eq < 0 ? chunk : chunk.slice(0, eq)).replace(/\+/g, ' '));
+        }
+        catch {
+            return null;
+        }
+        if (OTHER_WAYS_TO_PAY.has(key))
+            return null;
+        if (key.startsWith('payment_method_data[')) {
+            if (!replaced)
+                kept.push(`payment_method=${paymentMethod}`);
+            replaced = true;
+            continue;
+        }
+        kept.push(chunk);
+    }
+    return replaced ? kept.join('&') : null;
+}

package/dist/substitutions.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: 4079aa7704abbbbec052a96cb73463527ac5d027cd23780305c1e2ac954a5e88
+// artifact-sha256: 6209fa4a22c349d03eed24ea4ff9e626334c5975ec515a4b7f6a83592343274f
 // src/adyen-jwe.js
 var ADYEN_JWE_HEADER = { alg: "RSA-OAEP-256", enc: "A256GCM", version: "1" };
 var BASE64URL = /^[A-Za-z0-9_-]+$/;
@@ -78,6 +78,28 @@ function pathsOverlap(a, b) {
             return false;
     return true;
 }
+function sameKeyIgnoringCase(key, step) {
+    return !FORBIDDEN_KEYS.has(key) && (key.toLowerCase() === step.toLowerCase() || key.toUpperCase() === step.toUpperCase());
+}
+function valuesIgnoringCase(root, path) {
+    let nodes = [root];
+    for (const step of path) {
+        const next = [];
+        for (const node of nodes) {
+            if (typeof step === "number") {
+                if (Array.isArray(node) && Number.isSafeInteger(step) && step >= 0 && step < node.length)
+                    next.push(node[step]);
+            }
+            else if (isPlainObject(node)) {
+                for (const key of Object.keys(node))
+                    if (sameKeyIgnoringCase(key, step))
+                        next.push(node[key]);
+            }
+        }
+        nodes = next;
+    }
+    return nodes;
+}
 function describePath(path) {
     return path.length ? path.map((step) => typeof step === "number" ? `[${step}]` : `.${step}`).join("").replace(/^\./, "") : "(root)";
 }
@@ -117,7 +139,8 @@ function checkedSet(set, path, names, remove) {
     }
     return entries;
 }
-function swapMerchantHostedFields(body, spec) {
+var ADYEN_JWE = /* @__PURE__ */ Object.freeze({ accepts: isAdyenJweCompact, label: "an Adyen JWE" });
+function swapMerchantHostedFields(body, spec, ciphertext = ADYEN_JWE) {
     if (!isPlainObject(spec))
         throw new SubstitutionError("refusing a substitution that is not an object");
     for (const member of Object.keys(spec)) {
@@ -136,8 +159,8 @@ function swapMerchantHostedFields(body, spec) {
     for (const name of names) {
         if (FORBIDDEN_KEYS.has(name))
             throw new SubstitutionError(`refusing substitution field ${name}`);
-        if (!isAdyenJweCompact(fields[name]))
-            throw new SubstitutionError(`substitution for ${name} is not an Adyen JWE`);
+        if (!ciphertext.accepts(fields[name]))
+            throw new SubstitutionError(`substitution for ${name} is not ${ciphertext.label}`);
     }
     if (!Array.isArray(remove))
         throw new SubstitutionError("substitutions.remove is not a list");
@@ -169,8 +192,8 @@ function swapMerchantHostedFields(body, spec) {
         const dummy = Object.prototype.hasOwnProperty.call(holder.value, name) ? holder.value[name] : void 0;
         if (typeof dummy !== "string")
             throw new SubstitutionError(`the paused body has no string field ${name} at ${describePath(path)}`);
-        if (!isAdyenJweCompact(dummy))
-            throw new SubstitutionError(`the paused field ${name} is not an Adyen JWE`);
+        if (!ciphertext.accepts(dummy))
+            throw new SubstitutionError(`the paused field ${name} is not ${ciphertext.label}`);
         if (swaps.has(dummy))
             throw new SubstitutionError("two paused fields carry the same ciphertext");
         swaps.set(dummy, fields[name]);
@@ -247,6 +270,12 @@ function merchantAmountCardPaths(profile) {
     const rules = [source, isPlainObject(source.afterPayment) ? source.afterPayment : {}].flatMap((stage) => [...Array.isArray(stage.bind) ? stage.bind : [], ...Array.isArray(stage.match) ? stage.match : []]);
     return rules.flatMap((rule) => isPlainObject(rule) ? [rule.card, rule.whenCard] : []).filter(Array.isArray);
 }
+function merchantBodyAmountPaths(profile) {
+    const amount = isPlainObject(profile) ? profile.amount : void 0;
+    if (Array.isArray(amount))
+        return [amount];
+    return isPlainObject(amount) ? [amount.value, amount.currency].filter(Array.isArray) : [];
+}
 // src/merchant-profiles.js
 var MERCHANT_HOSTED_PROFILES = /* @__PURE__ */ deepFreeze([
     {
@@ -549,6 +578,154 @@ var MERCHANT_HOSTED_PROFILES = /* @__PURE__ */ deepFreeze([
             clientKey: "live_YJLFKT47JJG2RI7QIYX6HTKKDEDOEGOH",
             publicKeySha256: "da33611149dff3ab715be8671c0550bb8aec6112983b2473db9ee7afb829c110"
         }
+    },
+    {
+        // Read Sep 25, 2026, from public code only: the WooCommerce plugin super-payments 1.40.1 and
+        // cdn.superpayments.com/js/v2/payment.webcomponents.script.js as it stood on Sep 19.
+        // WePrescribe's page runs Super's <super-checkout> component, which picks the card leg per
+        // checkout session: ADYEN, under Super's own Adyen account (adyen-web 6.36.0 in Super's frame
+        // web-checkout.superpayments.com/adyen-card-host, which hands state.data to the page by
+        // postMessage), or STRIPE, a Payment Element the stripe definition already pays. On the ADYEN
+        // leg handleAdyenSubmit posts, with the session's Bearer token, {amount (the gross, minor
+        // units), currency, fundingMethod: {amount (the card's net share), type CARD, providerArgs:
+        // {type ADYEN, paymentMethod: {type CARD, the four JWEs, holderName, postalCode},
+        // browserInfo}}, rewardsToUse} from the page to api.superpayments.com. The card is charged
+        // fundingMethod.amount, so that is what the agent's amount must equal. No brand rides in the
+        // body. A saved card sends type SAVED_CARD with storedPaymentMethodId and no JWEs. Super's
+        // save-card component posts ciphertext to client.superpayments.com/setup-intent/confirm,
+        // which the WooCommerce checkout never calls. Public key read from checkoutshopper-live.adyen.com
+        // on 2026-09-25 and again on 2026-09-30 (UTC), unchanged. The path carries the checkout
+        // session id, which no preparation can name before the card request exists, so the review
+        // rules hold this profile in observe. A HAR still has to confirm the leg Super picks for a
+        // WePrescribe order and the body that leg posts.
+        id: "super_payments_checkout",
+        merchant: "Super Payments",
+        status: "observe",
+        origins: [{ checkout: "https://weprescribe.co.uk", endpoint: "https://api.superpayments.com" }],
+        method: "POST",
+        path: "/v3/checkout-sessions/:checkoutSessionId/payment",
+        query: {},
+        requires: [
+            { path: ["fundingMethod", "type"], equals: "CARD" },
+            { path: ["fundingMethod", "providerArgs", "type"], equals: "ADYEN" }
+        ],
+        holder: ["fundingMethod", "providerArgs", "paymentMethod"],
+        holderType: "CARD",
+        fields: {
+            encryptedCardNumber: "encryptedCardNumber",
+            encryptedExpiryMonth: "encryptedExpiryMonth",
+            encryptedExpiryYear: "encryptedExpiryYear",
+            encryptedSecurityCode: "encryptedSecurityCode"
+        },
+        remove: [],
+        refuse: [
+            { path: ["fundingMethod", "providerArgs", "paymentMethod", "storedPaymentMethodId"], when: "present" }
+        ],
+        amount: { value: ["fundingMethod", "amount"], currency: ["currency"], format: "number", unit: "minor" },
+        otherCardRequests: [{ origin: "https://client.superpayments.com", path: "/setup-intent/confirm" }],
+        adyen: {
+            environment: "live",
+            clientKey: "live_5MO5NXLPV5HPFJZWKYBAGA5RRMHEYWSD",
+            publicKeySha256: "b1cd67db43491625b433c9b864beea8a0f0351378bcd3e9e1e0f19e3aad38fcf"
+        }
+    },
+    {
+        // Read Sep 25, 2026, from public code only.
+        // www.corepoweryoga.com asks its API for a hosted payment page (the card-free POST
+        // api2.corepoweryoga.com/stored-payment answers hosted_payment_uri) and frames it: Zenoti
+        // Payments, Zenoti's Adyen platform, at corepoweryoga.zenoti.com/OnlinePayments/AdyentHPP.aspx,
+        // a cross-origin frame running adyen-web v6 Drop-in in the Advanced flow. Its makePayment
+        // (fintech-cdn.zenoti.com .../AdyentHPP.js, SHA-256 95e14da8...5df39) posts {processorId,
+        // subscriberId, transactionSource, paymentRequest: {paymentMethod: adyen-web's
+        // state.data.paymentMethod, type: that method's type, reference, BrowserInformation,
+        // shopperLocale, signature, channel, amount: {currency, value}, brand: onBrand's code for the
+        // typed card, FirstRecurringCharge}} to AdyentHPP.aspx/ProcessTransaction on the frame's own
+        // origin, and Zenoti's server calls Adyen /payments. The pair names the top page, the checkout
+        // the SDK prepares on. paymentRequest.brand describes the agent's dummy, so the approved card's
+        // brand is written there, beside the holder, and adyen-web's own brand at the holder is dropped.
+        // This request saves the card on file: CorePower then charges the stored card on its server
+        // (api2.corepoweryoga.com/purchase-invoice-cc-on-file) and memberships bill it monthly. The
+        // client key and environment arrive with the frame's per-session token, which only a signed-in
+        // shopper's page reads, so the key is a draft until a HAR pins it.
+        id: "zenoti_corepoweryoga_hpp",
+        merchant: "CorePower Yoga",
+        status: "observe",
+        origins: [{ checkout: "https://www.corepoweryoga.com", endpoint: "https://corepoweryoga.zenoti.com" }],
+        method: "POST",
+        path: "/OnlinePayments/AdyentHPP.aspx/ProcessTransaction",
+        query: {},
+        requires: [{ path: ["paymentRequest", "type"], equals: "scheme" }],
+        holder: ["paymentRequest", "paymentMethod"],
+        fields: {
+            encryptedCardNumber: "encryptedCardNumber",
+            encryptedExpiryMonth: "encryptedExpiryMonth",
+            encryptedExpiryYear: "encryptedExpiryYear",
+            encryptedSecurityCode: "encryptedSecurityCode"
+        },
+        remove: ["brand"],
+        refuse: [
+            { path: ["paymentRequest", "storePaymentMethod"], when: "true" },
+            { path: ["paymentRequest", "paymentMethod", "storedPaymentMethodId"], when: "present" },
+            { path: ["paymentRequest", "paymentMethod", "recurringDetailReference"], when: "present" }
+        ],
+        amount: ["paymentRequest", "amount"],
+        facts: [
+            // adyen-web's brand codes, as onBrand reports them.
+            {
+                path: ["paymentRequest", "brand"],
+                fact: "brand",
+                map: { visa: "visa", mastercard: "mc", amex: "amex", discover: "discover", diners: "diners", jcb: "jcb" }
+            }
+        ],
+        adyen: { environment: "live", clientKey: null, publicKeySha256: null }
+    },
+    {
+        // Read Sep 25, 2026, from public code only: the Cathay Payment Page bundle on
+        // payment.cathaypacific.com (main.14d368386ca2a9041a823b758307b3c2.js, adyen-web 5.71.5
+        // securedfields, environment live), where flight bookings and manage-booking pay. The page
+        // builds one outgoing request: amount and currency from the booking (a decimal
+        // number in major units; the cash part when miles pay the rest), the four JWEs at its root as
+        // encrypted_card_number, encrypted_expiry_month, encrypted_expiry_year and
+        // encrypted_security_code, raw_card_bin (the typed card's BIN, as adyen-web's issuerBin or
+        // binValue reports it), store_a_card, pay_with_stored_card, stored_card_token and
+        // pay_with_adyen_web true. signAndAuthorise posts {sign_request: that request, hpp_signature}
+        // to /cpp-paypage/v1/public/sign (header signapi: authorise, or its discount, currency, split,
+        // full-miles or bank-form variant), then a copy made before signing, plus the returned
+        // cpp_signature, to /cpp-paypage/v1/miles-plus-cash-authorise, which charges it. The signature
+        // covers the JWEs, so the card request is the signing step and the charge is its then request.
+        // raw_card_bin describes the dummy, so the approved card's BIN6 is written there, never more
+        // (adyen-web can report eight digits). The client key comes from document.cppData per
+        // session, so the key is a draft until a HAR pins it. The page's other card form sends a card
+        // alias (alias_card_number) in place of the JWEs, and a refuse rule below turns it away.
+        id: "cathay_cpp_sign",
+        merchant: "Cathay Pacific",
+        status: "observe",
+        origins: [{ checkout: "https://payment.cathaypacific.com", endpoint: "https://api.cathaypacific.com" }],
+        method: "POST",
+        path: "/cpp-paypage/v1/public/sign",
+        query: {},
+        requires: [
+            { path: ["sign_request", "pay_with_adyen_web"], equals: true },
+            { path: ["sign_request", "pay_with_stored_card"], equals: false },
+            { path: ["sign_request", "stored_card_token"], equals: "" }
+        ],
+        holder: ["sign_request"],
+        fields: {
+            encryptedCardNumber: "encrypted_card_number",
+            encryptedExpiryMonth: "encrypted_expiry_month",
+            encryptedExpiryYear: "encrypted_expiry_year",
+            encryptedSecurityCode: "encrypted_security_code"
+        },
+        remove: [],
+        refuse: [
+            { path: ["sign_request", "store_a_card"], when: "true" },
+            { path: ["sign_request", "stored_card_id"], when: "present" },
+            { path: ["sign_request", "alias_card_number"], when: "present" }
+        ],
+        amount: { value: ["sign_request", "amount"], currency: ["sign_request", "currency"], format: "number", unit: "major" },
+        facts: [{ path: ["sign_request", "raw_card_bin"], fact: "bin6" }],
+        then: { method: "POST", path: "/cpp-paypage/v1/miles-plus-cash-authorise", query: {}, holder: [] },
+        adyen: { environment: "live", clientKey: null, publicKeySha256: null }
     }
 ]);
 function adyenKeyHost(environment) {
@@ -627,7 +804,7 @@ function merchantProfileFactsRefusal(profile) {
     const list = (value) => Array.isArray(value) ? value : [];
     const reviewed = {
         written: [...isPlainObject(profile.fields) ? Object.values(profile.fields) : [], ...list(profile.remove)],
-        read: [...list(profile.requires), ...list(profile.refuse)].map((rule) => rule?.path).concat([profile.amount], merchantAmountCardPaths(profile)).filter(Array.isArray)
+        read: [...list(profile.requires), ...list(profile.refuse)].map((rule) => rule?.path).concat(merchantBodyAmountPaths(profile), merchantAmountCardPaths(profile)).filter(Array.isArray)
     };
     for (const [i, entry] of facts.entries()) {
         const refusal = factRefusal(entry, i, holder, besideHolder, reviewed);
@@ -642,28 +819,6 @@ function merchantProfileFactsRefusal(profile) {
 function merchantProfileRecognizerById(id) {
     return typeof id === "string" ? MERCHANT_PROFILE_RECOGNIZERS.find((entry) => entry.id === id) ?? null : null;
 }
-function sameKeyIgnoringCase(key, step) {
-    return !FORBIDDEN_KEYS.has(key) && (key.toLowerCase() === step.toLowerCase() || key.toUpperCase() === step.toUpperCase());
-}
-function valuesIgnoringCase(root, path) {
-    let nodes = [root];
-    for (const step of path) {
-        const next = [];
-        for (const node of nodes) {
-            if (typeof step === "number") {
-                if (Array.isArray(node) && Number.isSafeInteger(step) && step >= 0 && step < node.length)
-                    next.push(node[step]);
-            }
-            else if (isPlainObject(node)) {
-                for (const key of Object.keys(node))
-                    if (sameKeyIgnoringCase(key, step))
-                        next.push(node[key]);
-            }
-        }
-        nodes = next;
-    }
-    return nodes;
-}
 function merchantBodyRefusal(profile, body) {
     const p = merchantProfileRecognizerById(typeof profile === "string" ? profile : profile?.id);
     if (!p)
@@ -785,6 +940,9 @@ function substituteMerchantHosted(body, sub, opts) {
     const profile = merchantProfileRecognizerById(sub.profile);
     if (!profile)
         throw new SubstitutionError("the substitution names no merchant profile Agentcard reviewed");
+    if (profile.then !== void 0) {
+        throw new SubstitutionError(`${profile.merchant} takes the card in a second request too, and Agentcard does not write it there yet`);
+    }
     if (!sameSteps(sub.path, profile.holder)) {
         throw new SubstitutionError(`the substitution path is not where ${profile.merchant}'s card request holds the card`);
     }

package/dist/verifone.d.ts

@@ -0,0 +1,68 @@
+/** 'observe': paused, reported and aborted, never paid. 'enabled': a prepared checkout may pay its reviewed leg. */
+export type VerifoneProfileStatus = 'observe' | 'enabled';
+/** A reviewed Verifone profile this client armed: its id, the merchant it names, its environment and its effective status. */
+export interface VerifoneProfile {
+    readonly id: string;
+    readonly merchant: string;
+    readonly environment: 'production' | 'sandbox';
+    readonly status: VerifoneProfileStatus;
+}
+/** A profile's verdict on a paused request; see classifyVerifoneProfileRequest. */
+export type VerifoneRequestVerdict = {
+    verdict: 'pause';
+    leg: string;
+} | {
+    verdict: 'abort';
+    reason: string;
+} | {
+    verdict: 'pass';
+};
+/** The one substitution a Verifone approval writes: the device's blob at the leg's holder and field. */
+export interface VerifoneSubstitutions {
+    encoding: 'json';
+    kind: 'verifone';
+    profile: string;
+    blob: string;
+}
+/** Whether an entry the API served is a Verifone profile (`{ verifone_profile }`), never a recognizer. */
+export declare function isVerifoneProfileEntry(entry: unknown): boolean;
+/**
+ * The profiles this client arms: only the ones the API served, each once, in this
+ * build's order. A served entry is `{ verifone_profile: <the profile's wire
+ * projection> }`, and the first one that names a profile with exactly this build's
+ * rules (origins, legs, body rules, key subkey: everything but `status`) and a status
+ * this build knows decides it: 'enabled' only when both that entry and this build say
+ * so. A profile the API did not serve, or served with other rules, is not armed.
+ */
+export declare function armServedVerifoneProfiles(entries?: readonly unknown[]): VerifoneProfile[];
+/** The armed profile whose endpoint origin a URL is on, or null. */
+export declare function verifoneProfileFor(profiles: readonly VerifoneProfile[], url: string): VerifoneProfile | null;
+/** The Fetch.enable globs that pause every request to every armed profile's endpoint origins. */
+export declare function verifoneProfileUrlPatterns(profiles: readonly VerifoneProfile[]): string[];
+/** The verdict payment-core gives a request at an armed profile: pause (its reviewed leg), abort (a blob it cannot pay, with the reason) or pass. */
+export declare function classifyVerifoneProfileRequest(profile: VerifoneProfile, url: string, method: string, body: string | null | undefined): VerifoneRequestVerdict;
+/** The URL an event names for a request at an armed profile: its origin and, for a leg, the leg's path template; never a query or an id. */
+export declare function verifoneTemplatedUrl(profileId: string, url: string): string;
+/** The endpoint a Verifone preparation pays from a checkout page: the profile's leg URL, or null. */
+export declare function verifoneProfileEndpointFor(profileId: string, checkoutOrigin: string): string | null;
+/** Whether a paused request is the one a Verifone preparation for this profile consents to. */
+export declare function isPreparedVerifoneRequest(url: string, method: string, body: string | null, profileId: string): boolean;
+/** Whether an approval's substitution is exactly a Verifone blob for this profile. */
+export declare function isVerifoneSubstitution(sub: unknown, profileId: string): sub is VerifoneSubstitutions;
+/**
+ * The continuation of a Verifone approval: the live paused body with the device's blob in place
+ * of the page's placeholder blob. The API keeps no merchant body, so the live body must first
+ * hash to the one the API checked when the authorization was created (`bodySha256`); a page that
+ * rewrote its body while the cardholder decided is refused rather than paid. payment-core's
+ * substituteVerifoneBlob then reads the leg's rules on the live body again, writes only the blob,
+ * and refuses a profile that is not enabled or a blob under any other key. Throws
+ * SubstitutionError; nothing leaves the browser when it does.
+ */
+export declare function substituteVerifoneBody(request: {
+    url: string;
+    method: string;
+    body: string;
+}, replay: {
+    substitutions: VerifoneSubstitutions;
+    bodySha256: string;
+}): string;

package/dist/verifone.generated.d.ts

@@ -0,0 +1,51 @@
+declare var VERIFONE_KEY_PINS: any;
+declare function verifoneKeyPinShapeRefusal(entry: any): "verifone_key_pin_invalid" | "verifone_key_pin_mismatch" | null;
+declare var VERIFONE_MERCHANT_PROFILES: any;
+declare function verifoneProfileRefusal(profile: any, pins?: any): string | null;
+declare var VERIFONE_PROFILE_RECOGNIZERS: any;
+declare var VERIFONE_BLOB_PREFIX: string;
+declare function verifoneBlobInfo(value: any): Readonly<{
+    recipientKeyId: string;
+    wrappedKeyLength: any;
+    armorHeaders: readonly any[];
+}> | null;
+declare function isVerifoneBlob(value: any): boolean;
+declare var VERIFONE_TEST_PANS: readonly string[];
+declare var VERIFONE_CLOCK_SKEW_MS: number;
+declare var VERIFONE_BLOB_MAX: number;
+declare function carriesVerifoneBlob(body: any): any;
+declare function verifoneCardPlaintext(card: any, nowMs: any): string;
+declare function verifoneClockSkewRefusal(deviceNowMs: any, serverNowMs: any): "verifone_clock_unknown" | "verifone_clock_skew" | null;
+declare var VERIFONE_SUBSTITUTION: Readonly<{
+    at: "merchant_profile";
+    fields: readonly string[];
+}>;
+declare function classifyVerifoneRequest(profileId: any, url: any, method: any, body: any): Readonly<{
+    verdict: "pass";
+}> | Readonly<{
+    verdict: "abort";
+    reason: any;
+}> | Readonly<{
+    verdict: "pause";
+    leg: any;
+}>;
+declare function verifoneLegName(profileId: any, url: any, method: any, checkoutOrigin: any): any;
+declare function verifonePlaceholderBlob(profileId: any, request: any): string | null;
+declare function encryptVerifoneCard(card: any, request: any, facilities: any): Promise<string>;
+declare function verifoneSubstitution(profileId: any, blob: any): {
+    encoding: string;
+    kind: string;
+    profile: any;
+    blob: string;
+};
+declare function substituteVerifoneBlob(request: any, sub: any): string;
+declare function verifoneApprovedBlobRefusal(blob: any, context: any): "verifone_substitution_invalid" | "verifone_approval_context_invalid" | "verifone_profile_unknown" | "verifone_request_invalid" | "verifone_key_unpinned" | "verifone_environment_mismatch" | "verifone_key_mismatch" | "verifone_blob_unchanged" | null;
+declare function isPreparedVerifoneRequest(url: any, method: any, body: any, profileId: any): boolean;
+declare function verifoneProfileEndpointFor(profileId: any, checkoutOrigin: any): string | null;
+declare function verifoneProfileTemplatedUrl(profileId: any, url: any): string;
+declare function verifoneProfileUrlGlobs(profileId: any): unknown[];
+declare function verifoneProfileAmountPath(profileId: any): any[] | null;
+declare function verifoneProfileEnvironment(profileId: any): any;
+declare function verifoneMerchantProfile(id: any): any;
+declare function verifoneProfileRulesMatch(profileId: any, served: any): boolean;
+export { VERIFONE_BLOB_MAX, VERIFONE_BLOB_PREFIX, VERIFONE_CLOCK_SKEW_MS, VERIFONE_KEY_PINS, VERIFONE_MERCHANT_PROFILES, VERIFONE_PROFILE_RECOGNIZERS, VERIFONE_SUBSTITUTION, VERIFONE_TEST_PANS, carriesVerifoneBlob, classifyVerifoneRequest, encryptVerifoneCard, isPreparedVerifoneRequest, isVerifoneBlob, substituteVerifoneBlob, verifoneApprovedBlobRefusal, verifoneBlobInfo, verifoneCardPlaintext, verifoneClockSkewRefusal, verifoneKeyPinShapeRefusal, verifoneLegName, verifoneMerchantProfile, verifonePlaceholderBlob, verifoneProfileAmountPath, verifoneProfileEndpointFor, verifoneProfileEnvironment, verifoneProfileRefusal, verifoneProfileRulesMatch, verifoneProfileTemplatedUrl, verifoneProfileUrlGlobs, verifoneSubstitution };