@agent-cards/sdk 0.23.28 → 0.24.1

package/dist/checkout-com.generated.js

@@ -1,11 +1,12 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: aaa2f76129db849a23bf8bb44043f5cff2b45e853b16b5de4d61a1f6a10cd392
+// artifact-sha256: a4f45fd0e69b19e8cb2da463b865012950ae5bcc9971c01d3e348a7de1a255ef
 // src/checkout-com.js
 var ENDPOINTS = Object.freeze({
     production: ["https://api.checkout.com/tokens", "https://card-acquisition-gateway.checkout.com/tokens"],
     sandbox: ["https://api.sandbox.checkout.com/tokens", "https://card-acquisition-gateway.sandbox.checkout.com/tokens"]
 });
+var MERCHANT_ENDPOINT = /^https:\/\/(?:[a-z0-9]+\.)?(?:api(\.sandbox)?\.checkout\.com\/tokens|devices\.api(\.sandbox)?\.checkout\.com\/(?:cag\/)?tokens)$/;
 var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var own = (value, name) => Object.prototype.hasOwnProperty.call(value, name);
 var keys = (value, allowed) => record(value) && Object.keys(value).every((name) => allowed.includes(name));
@@ -123,6 +124,9 @@ function checkoutComEnvironment(url) {
         return "production";
     if (ENDPOINTS.sandbox.includes(url))
         return "sandbox";
+    const merchant = typeof url === "string" ? MERCHANT_ENDPOINT.exec(url) : null;
+    if (merchant?.[0] === url)
+        return merchant[1] || merchant[2] ? "sandbox" : "production";
     return void 0;
 }
 var ADDRESS_TEXT = ["address_line1", "address_line2", "city", "state", "zip", "name"];

package/dist/client.d.ts

@@ -7,8 +7,8 @@ import { type VerifoneProfile, type VerifoneSubstitutions } from './verifone.js'
 import { type MerchantSessionCapture } from './merchant-session-probe.js';
 import { type PaddleTokenexServedFacts } from './paddle-tokenex.js';
 import type { PaddleCheckoutCapture } from './paddle-checkout-watch.js';
-import { VoiceModule, type VoiceOptions } from './voice.js';
 import { BuyModule } from './buy.js';
+import { ApprovalsModule } from './approvals.js';
 import { RequestRegistry } from './requests.js';
 import type { ApiTransport } from './api-module.js';
 import { type MicroformField, type MicroformSidecar } from './cybersource-flex.js';
@@ -121,6 +121,15 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * recognizer is never in BUILTIN_REGISTRY, so a build reaches it only through a
  * sync that declares its capability, and whether an org may pay through it
  * stays the API's decision.
+ * `bluesnap_hosted_payment_fields`: BlueSnap's Hosted Payment Fields, whose card
+ * number, expiry and code frames each PUT their own field as JSON to the
+ * merchant's payment-fields token. This build pauses the card number PUT, holds
+ * the expiry and code PUTs and answers them with its answer (aci.ts, the JSON
+ * split card), and the cardholder's device sends the whole card in that one PUT
+ * (payment-core processors/bluesnap.js). The request names no amount, so the
+ * agent's pair, above zero, is the one the cardholder approves. Served on the
+ * same terms: only to a build that lists it, for a company Agentcard turned
+ * BlueSnap on for.
  * `creditguard_pps_process`: CreditGuard's hosted payment page (Hyp PPS), whose
  * card submit this build pays only under a prepared checkout that names the
  * framed page (prepare({ psp: 'creditguard', environment, paymentPageUrl })). The
@@ -459,6 +468,18 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * page the create names. Served on the same terms: only to a build that lists it, for a company
  * Agentcard turned Pin Payments on for.
  *
+ * `paymentwall_card_token`: the card request Paymentwall's card form (Brick) sends, from its number
+ * frame on pwgateway.com inside Paymentwall's hosted widget or from a merchant's own page: a form POST
+ * to https://pwgateway.com/api/token (https://api.paymentwall.com/api/brick/token for a test key)
+ * under the merchant's public key. This build pauses only the card form's own body at those exact
+ * URLs (payment-core processors/paymentwall.js); a stored card's code, a wallet's token, a brand from
+ * the page's select or any other body there fails in the browser before anything is created. The
+ * cardholder's device sends the request itself with the real card, and the page gets the token answer
+ * payment-core's judge rebuilt. The request names no amount, so the agent's pair, above zero, is the
+ * one the cardholder approves, and the API pays only a Paymentwall project payment-core pins for the
+ * checkout page the create names. Served on the same terms: only to a build that lists it, for a
+ * company Agentcard turned Paymentwall on for.
+ *
  * `sbps_token_jsonp`: SB Payment Service's card token request, the JSONP <script>
  * GET its token script sends to /token/generateToken on token.sps-system.com. This
  * build pauses it only as the browser writes it, aborts any other request on that
@@ -475,6 +496,56 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * Served on the same terms, and the API holds the lane to Agentcard's own company
  * until a reviewed change binds the client key to the merchant.
  *
+ * `iyzico_checkout_form`: the card payment iyzico's Checkout Form posts as one JSON request to
+ * api.iyzipay.com/payment/iyzipos/checkoutform/auth/ecom, or initialize3ds/ecom for 3-D Secure
+ * (sandbox-api.iyzipay.com in test), under the form's X-IYZI-TOKEN. This build pauses only the
+ * form's own payment with a new card at those exact URLs (payment-core processors/iyzico.js); a saved
+ * card, a card kept on file, installments and a currency conversion fail in the browser before
+ * anything is created. The cardholder's device sends the payment itself, and the page gets iyzico's
+ * answer as payment-core's judge rebuilt it: the payment done, or the bank's 3-D Secure page, which
+ * the form then runs in the agent's browser. The payment names its price but not its currency, so
+ * authorize() needs the agent's pair, and the API holds its amount to the price. Served on the same
+ * terms, and the API holds the lane to Agentcard's own company.
+ *
+ * `aurus_one_time_token`: the card request Aurus Pay's ecom card frame (O'Reilly Auto Parts) sends to
+ * pecst<NN>.aurusepay.com/storeservices/ecom/oneTimeToken, the card sealed in the frame under a public key its own
+ * script carries. This build pauses it only when Aurus's card frame sent it (aurus.ts aurusPreClaim); the same
+ * request from the store's page or another frame fails in the browser before anything is created. The request
+ * names no amount, so authorize() needs the agent's pair, above zero. The cardholder's device does not seal for
+ * Aurus yet (payment-core processors/aurus.js), so a paused request opens no approval that pays.
+ *
+ * `viva_smart_checkout_chargetoken`: the card request Viva Wallet's Smart Checkout page sends as one
+ * JSON request to www.vivapayments.com/web2/checkout/v2/chargetokens (demo.vivapayments.com in test),
+ * on Pay, after the page's own reCAPTCHA run. This build pauses only the page's own card body at that
+ * exact URL (payment-core processors/viva_wallet.js); a body that keeps the card, pays with a stored
+ * card, converts the currency or is the page's second try after a decline fails in the browser before
+ * anything is created. The cardholder's device sends the card through Agentcard's checkout relay, since
+ * the page's request answers no other origin, and the page gets Viva's single-use charge token as
+ * payment-core's judge rebuilt it; the page then charges that token card free. The body names its
+ * amount, which the API holds to the agent's pair, and the API pays a live token only for an order
+ * payment-core pins. Served on the same terms, and the API holds the lane to Agentcard's own company.
+ *
+ * `paystack_pinned_key`: the charge Paystack's hosted checkout sends as one form POST to
+ * standard.paystack.co/charge/, the card only as `clientdata`, RSA ciphertext under the one key
+ * Paystack's page carries. This build pauses only the card page's own charge at that exact URL
+ * (payment-core processors/paystack.js); a charge that keeps the card, starts a plan or carries a PIN
+ * fails in the browser before anything is created. The cardholder's device encrypts the real card under
+ * the same pinned key and sends the charge itself, and the page gets Paystack's answer: paid, declined,
+ * or the issuer's 3-D Secure step, which the page then runs in the agent's browser. The charge names
+ * no amount, so authorize() needs the agent's pair, above zero. Served on the same terms, and the API
+ * holds the lane to Agentcard's own company.
+ *
+ * `usaepay_payment_key`: the card request USAePay's Pay.js card frame sends as one JSON request to
+ * www.usaepay.com/api/v2/pub/payment_keys (secure.usaepay.com alike; sandbox.usaepay.com in test), under
+ * the merchant's public key in its Authorization. This build pauses only the frame's own card body at
+ * that exact URL (payment-core processors/usaepay.js); a Google Pay or Apple Pay token and a bank
+ * account on the same URL fail in the browser before anything is created. The cardholder's device sends
+ * the card through Agentcard's checkout relay, since USAePay answers no browser origin, and the frame
+ * gets USAePay's single-use payment key as payment-core's judge rebuilt it; the merchant's server
+ * charges that key afterwards. The request names no amount, so authorize() needs the agent's pair, and
+ * the API pays a live key only to a merchant payment-core pins for the checkout page. Served on the same
+ * terms, and the API holds the lane to Agentcard's own company.
+ *
  * `tap_card_sdk_token`: the token request Tap Payments' card frame sends to sdk.tap.company, carrying
  * the card only as one ciphertext the frame writes under the merchant's own RSA key. This build pauses
  * it and writes over the placeholder's ciphertext the one the cardholder's device wrote under the key
@@ -502,6 +573,41 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * (agent-amount-processors.json), is the one the cardholder approves. Served on the same terms: only
  * to a build that lists it, for a company Agentcard turned Openpay on for.
  *
+ * `processout_card_token`: the card request ProcessOut.js's card frame sends from js.processout.com to
+ * api.processout.com/cards under the store's project id, only through a prepared checkout: the frame
+ * gives the page 20 seconds from the shop's continue press, so the cardholder approves before it. The
+ * card URL names the project in its query, so the claim binds the request by its project's environment
+ * and its shape, never by the prepared URL. The cardholder's device sends the card to ProcessOut itself
+ * and the frame gets back ProcessOut's token alone, rebuilt by payment-core's judge. The request names
+ * no amount, so the agent's pair, above zero (agent-amount-processors.json), is the one the cardholder
+ * approves. Served on the same terms: only to a build that lists it, for a company Agentcard turned
+ * ProcessOut on for.
+ *
+ * `monei_card_token`: the card request MONEI's card frame sends from MONEI's payment page
+ * (secure.monei.com/payments/<id>) to api.monei.com/v1/tokens, with the payment's id and the card. This
+ * build pauses only the frame's own body for a payment at that exact URL (payment-core
+ * processors/monei.js); MONEI's account flow, Click to Pay and a wallet on the same URL fail in the
+ * browser before anything is created. The request names neither the merchant nor the amount, so the API
+ * reads MONEI's own record of the payment and holds the agent's pair, above zero
+ * (agent-amount-processors.json), to MONEI's amount exactly. The cardholder's device sends the card to
+ * MONEI itself and the frame gets back MONEI's payment token alone, rebuilt by payment-core's judge.
+ * Served on the same terms: only to a build that lists it, for a company Agentcard turned MONEI on for.
+ *
+ * `frisbii_card_token`: the card request Frisbii Checkout's hosted payment page (checkout.reepay.com or
+ * checkout.frisbii.com, as an overlay, an embedded frame or a full window) sends to
+ * card.reepay.com or card.frisbii.com /v1/token/?session=<id>, with the merchant's public key and the
+ * card. This build pauses only the page's own body at that exact URL (payment-core
+ * processors/frisbii.js); any other body on it, one that keeps the card on file included, fails in the
+ * browser before anything is created. The page's two other card paths, a stored card's token
+ * (/v1/token/cof/) and Click to Pay (/v1/token/create_click_to_pay), are held and refused whatever
+ * their body, so neither leaves the browser either. The request names the amount only when
+ * the session carries 3-D Secure data, so the agent's pair is required, above zero
+ * (agent-amount-processors.json), and the API refuses it when it differs from the page's own. The
+ * cardholder's device sends the card to Frisbii
+ * itself and the page gets back Frisbii's card token or 3-D Secure step alone, rebuilt by payment-core's
+ * judge. Served on the same terms: only to a build that lists it, for a company Agentcard turned Frisbii
+ * on for.
+ *
  * `aps_custom_merchant_page`: Amazon Payment Services' custom merchant page, whose own card form
  * posts top-level to /FortAPI/paymentPage on checkout.payfort.com (sbcheckout.payfort.com on APS's
  * sandbox) with service_command=TOKENIZATION. This build pauses that navigation; the cardholder's
@@ -522,6 +628,14 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * the cardholder approves, and the API holds its amount to the body's. Served on the same terms: only to a build
  * that lists it, for a company Agentcard turned Nexi Checkout on for.
  *
+ * `oceanpayment_hosted_payment_page`: the card post of Oceanpayment's hosted payment page (secure.oceanpayment.com, where
+ * Oceanpayment's Shopify redirect app sends the buyer), a native form post to /gateway/sendPay;jsessionid=<session> with
+ * the card in clear (test-secure.oceanpayment.com for a test row). This build pauses only that post, exactly as the page's
+ * form action writes it, and aborts every other post to Oceanpayment's two hosts (oceanpayment.ts), so the agent's
+ * placeholder never reaches Oceanpayment; the cardholder's device writes the real card into the paused post and sends it
+ * through the checkout relay. The post names no amount, so the agent's pair, above zero, is the one the cardholder
+ * approves. Served on the same terms: only to a build that lists it, for a company Agentcard turned Oceanpayment on for.
+ *
  * `barion_hosted_payment_page`: Barion's Smart Gateway, whose card-free link
  * (secure.barion.com/Pay?Id=<payment id>, a plain GET the merchant's redirect or script sends
  * the buyer to) this build pauses for the cardholder's device by its exact link (hosted-entry.ts),
@@ -529,6 +643,27 @@ export declare const SUPPORTED_REGISTRY_FEATURES: readonly string[];
  * send (pre-claim.ts, barion.ts). Served on the same terms as Przelewy24's: only to a build that
  * lists it, for a company Agentcard turned Barion on for.
  *
+ * `payplug_hosted_payment_page`: PayPlug's payment page, whose card-free link
+ * (secure.payplug.com/pay/<payment id>, or /pay/test/<payment id>, a plain GET the merchant's
+ * redirect or script sends the buyer to) this build pauses for the cardholder's device by its exact
+ * link (hosted-entry.ts), and whose card post this build never lets the agent's browser send
+ * (pre-claim.ts, payplug.ts). The link names no amount, so authorize() asks for the agent's, above
+ * zero. Served only to a build that lists it, and the API turns PayPlug on for Agentcard's own
+ * company alone.
+ *
+ * `cardlink_vpos_hosted_payment_page`: Cardlink's VPOS, the payment page of Eurobank, Cardlink and Nexi
+ * Greece, whose card-free signed entry (a form post to /vpos/shophandlermpi on one of the three hosts) this build
+ * pauses for the cardholder's device, and whose card page's post and card check on the same URL this build never
+ * lets the agent's browser send (pre-claim.ts, cardlink-vpos.ts). Served only to a build that lists it, and the API
+ * turns the lane on for Agentcard's own company alone.
+ *
+ * `eghl_hosted_payment_page`: eGHL's payment page (ADAPTIS, formerly eGHL, on securepay.e-ghl.com), whose card-free
+ * entry (a GET of /IPG/payment.aspx with the payment in its query, which the merchant's checkout or eGHL's Shopify app
+ * sends the buyer to) this build pauses for the cardholder's device by its exact URL (hosted-entry.ts), and whose card
+ * page's post to the same address this build never lets the agent's browser send (pre-claim.ts, eghl.ts). The entry
+ * names its amount, and the API holds the agent's pair to it exactly. Served only to a build that lists it, and the API
+ * turns the lane on for Agentcard's own company alone.
+ *
  * `paymob_checkout_pay`: the card payment Paymob's own checkout sends, from Unified Checkout
  * (<country>.checkout.paymob.com) or from the Pixel card frame a merchant's page embeds, as JSON to
  * https://<accept|uae|ksa|oman>.paymob.com/api/acceptance/payments/pay. This build pauses only the
@@ -789,6 +924,14 @@ export interface CardEndpointReplay extends ExecutionMetadata {
     body: string;
     withheld: 'card_in_response' | 'unreadable_in_response' | 'refused_step_in_response' | null;
     amountAuthority?: AmountAuthority;
+    /**
+     * The amount the cardholder approved, an integer in the currency's smallest unit with its code, as the API's read
+     * names it; absent when it names none. Nike's order after its card is held to it (nike-order.ts).
+     */
+    approved?: {
+        amount: number;
+        currency: string;
+    };
 }
 /**
  * The device_encrypt flow (Payrails): the cardholder's device encrypted the
@@ -1019,6 +1162,12 @@ export interface AuthorizeInput extends ExecutionMetadata {
     };
     /** Milliseconds from the caller's pay click until the SDK caught the card request, measured on one clock. */
     payToInterceptMs?: number;
+    /**
+     * When the card request paused, in epoch milliseconds on this machine's clock; the adapters fill it. A VTEX Payments
+     * card post, whose checkout gives the post 12 seconds, sends how long ago that was (`paused_ms`), and the API counts
+     * the row's send-by from it.
+     */
+    pausedAt?: number;
     /**
      * WHICH stored card should pay — a vault card id from
      * GET /api/v2/vault_cards. The approval page preselects it (the human can
@@ -1562,13 +1711,6 @@ export interface VaultClientOptions {
      * the error is thrown. Default [500, 1500]; [] disables retries.
      */
     unverifiableRetryDelaysMs?: number[];
-    /**
-     * The voice module: how this product approves purchases by voice, named
-     * once per business, with the Vault return link and the verifier address
-     * beside it. Leave it out and the client approves on Agentcard's page
-     * (`approval: 'sheet'`). See `VoiceOptions`.
-     */
-    voice?: VoiceOptions;
     /**
      * Test mode only: run a merchant-hosted checkout against your own Adyen TEST
      * account. Each entry arms your own endpoint as taking the card request of a
@@ -1626,22 +1768,22 @@ export declare class VaultClient {
      * false: a live client.
      */
     get sandbox(): boolean;
-    /** What every module shares: the token, the HTTP path, the poll settings and the language list. */
+    /** What every module shares: the token, the HTTP path and the poll settings. */
     protected readonly transport: ApiTransport;
-    /**
-     * Approve purchases by voice inside your own product: connect a person once,
-     * create the purchase, ask for the key word, read the result. Same
-     * credentials, same token as the checkout calls. Approves on Agentcard's
-     * page unless `voice: { approval: 'in_app' }` was named at construction.
-     */
-    readonly voice: VoiceModule;
     /**
      * The Purchase API from the same client: ask for a cart on behalf of a
      * person you connected, confirm it by its hash, and name an approval the
-     * person already gave by voice so the API places against it and asks for
-     * nothing a second time. Same credentials, same token as the voice calls.
+     * person already gave so the API places against it and asks for
+     * nothing a second time. Same credentials, same token as the checkout calls.
      */
     readonly buy: BuyModule;
+    /**
+     * Purchases your server creates for a person, approved on Agentcard's page:
+     * create one (`request: 'sandbox'` under a sandbox client), send the person
+     * its `approval_url`, then read the decision or wait for it. Same
+     * credentials, same token as the checkout calls.
+     */
+    readonly approvals: ApprovalsModule;
     /**
      * The request builders: the processor requests a purchase pauses on, the
      * shipped ones and yours (`requests.register`, `requests.build`).
@@ -1865,9 +2007,9 @@ export declare class VaultClient {
      * exactly the approved payment method (the page's own, or written by the
      * adapters in place of a card the confirm carries again).
      * The API allows a card save for any company, for an approval given on the
-     * Vault page, not by voice, with no amount, and a SetupIntent Stripe reports
-     * still confirmable on the same Stripe account; any other answer rejects with
-     * a CheckoutApiError whose code says why (for example `amount_mismatch`, or
+     * Vault page, with no amount, and a SetupIntent Stripe reports still
+     * confirmable on the same Stripe account; any other answer rejects with a
+     * CheckoutApiError whose code says why (for example `amount_mismatch`, or
      * `continuation_invalid` for a confirm that is not a card-free SetupIntent
      * confirm). Nothing
      * is charged: the adapters continue the page's request once this resolves.
@@ -1983,7 +2125,9 @@ export declare class VaultClient {
      * (Stripe did not answer the read-back) is retried on a short backoff
      * instead of being left to the page's own retry loop, and a 409
      * `amount_mismatch` becomes an AmountMismatchError at stage 'create' so the
-     * adapters treat it as an answered request, not a dead page.
+     * adapters treat it as an answered request, not a dead page. `atSend` adds
+     * fields counted as each request leaves, after any token wait, 401 refresh or
+     * backoff, so a field that measures time (VTEX's paused_ms) measures it then.
      */
     private createAuthorization;
     private token;
@@ -2000,9 +2144,13 @@ export declare class VaultClient {
      * Only fetch and a successful response's body read belong to that retry:
      * OAuth, HTTP errors, invalid JSON and every mutation remain outside it.
      * The existing one-time 401 refresh carries the remaining read budget.
+     * `bodyAt`, when given, builds the body as each request leaves, after the
+     * token and on the 401 refresh's resend, in place of `init.body`.
      */
     private call;
     private post;
+    /** A POST whose body is built as each request leaves (call's `bodyAt`), for a body that counts time. */
+    private postAtSend;
     private get;
     private readPreparation;
 }