@agent-cards/sdk 0.23.19 → 0.23.21

package/dist/cdp.d.ts

@@ -1,5 +1,6 @@
 import { type VaultClient, type ExecutionMetadata } from './client.js';
 import { type StripeCheckoutOptions } from './stripe-checkout.js';
+import { type HoldOptions } from './hold.js';
 import { type CheckoutController, type LifecycleOptions, type PaymentEndpointGuard, type PausedCheckout } from './lifecycle.js';
 /**
  * The CORS headers a fulfilled CROSS-ORIGIN request needs, or null when the
@@ -112,6 +113,34 @@ export interface AttachOptions extends LifecycleOptions, ExecutionMetadata {
     pauseOnly?: boolean;
     /** With `pauseOnly`: the paused request and the controller to resume it on. Required when `pauseOnly` is set. */
     onPaused?: (paused: PausedCheckout) => void | Promise<void>;
+    /**
+     * Hold mode (CARD-REQUEST-HOLD.md): the first card request pauses and is HELD with nothing created, and
+     * `controller.hold` (CardRequestHold) answers it. `controller.release({ amount, currency, pageTotal })` creates the
+     * authorization only then, at the total the person confirmed, and only when the page shows it; a live client
+     * answers the page with the device's replay, a sandbox client never sends the request on. `controller.hold.cancel()`
+     * fails it. A request held past its processor's own wait is cancelled first. One request is held at a time; every
+     * other card request, and every one after a decision, fails at once. Besides the registry's processors, a hold
+     * catches Bolt's sealed tokenizer and, with `placeholderNumbers`, any request carrying the placeholder card (both
+     * cancel-only, except a sandbox placeholder post released with `continuePlaceholder`). Raw CDP only; not with
+     * `pauseOnly`. Service workers are bypassed in this mode unless `serviceWorkers: 'refuse'`.
+     */
+    hold?: boolean | HoldOptions;
+    /**
+     * A site service worker in the merchant's browser context. `refuse` (default): the attachment refuses the context,
+     * since a worker can send a card request outside the frames' interception. `bypass` (default in hold mode): every
+     * armed frame sends its requests past service workers (Network.setBypassServiceWorker), so the worker is accepted.
+     */
+    serviceWorkers?: 'refuse' | 'bypass';
+    /**
+     * A shared worker in the merchant's browser context (chewy.com runs three from blob: URLs). Its own requests pause
+     * nowhere: Fetch reaches no shared worker. `refuse` (default): the attachment refuses the context. `accept`
+     * (default in hold mode): the worker is accepted unwatched and a `shared_worker_unwatched` event names it; nothing
+     * it sends can be approved, and the browser only ever holds the placeholder card. Kernel answers an attach to such
+     * a worker with "Not allowed" and closes the connection, so `accept` never attaches. `observe`: the worker is
+     * attached and its Network reports read; a card request it sends ends the checkout and any hold, with nothing
+     * approved (a browser that allows the attach only).
+     */
+    sharedWorkers?: 'refuse' | 'accept' | 'observe';
     /** Explicit native hosted Stripe Checkout TEST integration; requires an Autopilot grant. */
     stripeCheckout?: StripeCheckoutOptions;
     /** Fallback when the browser cannot expose its top-level origin. Never an amount/payee authority. */