@conto_finance/sdk 0.6.0-beta.2 → 0.6.1

package/dist/index.d.mts

@@ -1,3 +1,513 @@
+type PurchaseStatus = 'queued' | 'running' | 'awaiting_action' | 'submitting' | 'reconciling' | 'succeeded' | 'blocked' | 'failed' | 'cancelled';
+type PurchasePhase = 'queued' | 'shopping' | 'checkout' | 'review' | 'scheduled' | 'authorization' | 'payment' | 'reconciliation' | 'closed_unconfirmed' | 'complete';
+type PurchaseActionKind = 'buyer_details' | 'purchase_review' | 'organization_approval' | 'card_verification' | 'merchant_signin' | 'merchant_challenge';
+type PurchaseActionAuthority = 'agent_or_buyer' | 'buyer' | 'cardholder' | 'organization';
+interface PurchaseMoney {
+    /** Positive integer in minor units. */
+    amountMinor: number;
+    /** Uppercase ISO 4217. Purchases support USD only. */
+    currency: string;
+}
+interface PurchaseItem {
+    url: string;
+    title?: string;
+    quantity?: number;
+    options?: string[];
+}
+interface PurchaseAction {
+    id: string;
+    kind: PurchaseActionKind;
+    /** Only `agent_or_buyer` accepts `purchases.respond()`. */
+    authority: PurchaseActionAuthority;
+    revision: number;
+    expiresAt: string;
+    /** For buyer_details: the form and the field names it accepts. */
+    form?: 'delivery' | 'billing' | 'store_order_contact';
+    fields?: string[];
+    /**
+     * For buyer, cardholder and reviewer actions: the Conto page that completes
+     * it. It works only inside a hosted buyer session or the dashboard, so it is
+     * safe to show. For a seamless buyer handoff, have your server create a
+     * hosted action link with `ContoAdmin.purchasing.purchases.createActionLink()`.
+     */
+    url?: string;
+}
+interface PurchaseEvidence {
+    authorization: {
+        state: 'not_requested' | 'pending_review' | 'issued' | 'denied' | 'cancelled' | 'unknown';
+    };
+    merchant: {
+        state: 'not_submitted' | 'confirmed' | 'unknown';
+        source?: string;
+        reference?: string;
+        amount?: PurchaseMoney;
+        amountVerified?: boolean;
+        observedAt?: string;
+    };
+    /** Never observed: the card provider reports issuance only. */
+    settlement: {
+        state: 'unknown';
+        reason: 'NOT_REPORTED_BY_PROVIDER';
+    };
+}
+interface Purchase {
+    id: string;
+    object: 'purchase';
+    buyerId: string;
+    agentId: string;
+    environment: 'live' | 'test';
+    status: PurchaseStatus;
+    phase: PurchasePhase;
+    /** Increases by one with every visible change. */
+    version: number;
+    request: {
+        url: string;
+        task?: string;
+        items?: PurchaseItem[];
+    };
+    maxCost: PurchaseMoney;
+    quote: {
+        merchant: string;
+        description: string | null;
+        total: PurchaseMoney;
+        estimatedTax: boolean;
+    } | null;
+    requiredAction: PurchaseAction | null;
+    result: {
+        outcome: 'merchant_confirmed' | 'checkout_reported' | 'credential_unused' | 'not_completed' | 'denied' | 'cancelled';
+        merchantReference: string | null;
+    } | null;
+    paymentEvidence: PurchaseEvidence;
+    progress: {
+        steps: number;
+        message: string | null;
+    };
+    reasonCode: string | null;
+    cancellation: {
+        requestedAt: string;
+    } | null;
+    /** Present when the purchase pays under one of the buyer's open allowances. */
+    allowance?: {
+        id: string;
+        reviewSkipped: boolean;
+    };
+    /** Present when the purchase is one cycle of a repeat order. */
+    recurrence?: {
+        id: string;
+        cycleKey: string;
+        payAt: string | null;
+        changes: {
+            previousTotal?: {
+                amountMinor: number;
+                currency: string;
+            };
+            itemsChanged: boolean;
+        } | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+interface PurchaseEvent {
+    id: string;
+    purchaseId: string;
+    version: number;
+    /** purchase.created, purchase.updated, purchase.action_required, purchase.<final status>, or purchase.resync */
+    type: string;
+    createdAt: string;
+    data: Purchase;
+}
+interface PurchaseEventPage {
+    items: PurchaseEvent[];
+    latestVersion: number;
+    nextCursor: number;
+    hasMore: boolean;
+}
+interface PurchaseList {
+    items: Purchase[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface CreatePurchaseInput {
+    buyerId: string;
+    request: {
+        url: string;
+        task?: string;
+        items?: PurchaseItem[];
+    };
+    /** The most this purchase may cost, delivered. It narrows the delegation, never widens it. */
+    maxCost: PurchaseMoney;
+    /**
+     * The card and delegation to pay with. Leave it out when the buyer has one
+     * active delegation for the store: a test card for a Conto test store, a
+     * live card otherwise. With more than one, the API refuses with
+     * `PAYMENT_METHOD_REQUIRED`.
+     */
+    payment?: {
+        methodId: string;
+        delegationId: string;
+    };
+    /** The buyer id, to use the buyer's saved delivery details. */
+    buyerProfileId?: string;
+}
+interface PurchaseResponseAck {
+    id: string;
+    object: 'purchase_response';
+    purchaseId: string;
+    actionId: string;
+    /** accepted: recorded, not yet applied. applied: used. rejected: could not be used. */
+    status: 'accepted' | 'applied' | 'rejected';
+    reasonCode: string | null;
+    acceptedAt: string;
+    appliedAt: string | null;
+    replayed: boolean;
+}
+type CancellationOutcome = 'cancelled' | 'requested' | 'too_late' | 'already_final';
+interface WatchPurchaseOptions {
+    /** Resume after this version. Defaults to 0, the full history. */
+    after?: number;
+    signal?: AbortSignal;
+    /** auto streams and falls back to polling. Defaults to auto. */
+    mode?: 'auto' | 'stream' | 'poll';
+    /** Polling interval. Defaults to 2000 ms. */
+    pollIntervalMs?: number;
+    /** Stop waiting after this long. Defaults to no limit. */
+    maxWaitMs?: number;
+}
+declare const isFinalPurchaseStatus: (status: PurchaseStatus) => boolean;
+interface PurchaseTransport {
+    request<T>(method: string, path: string, body?: Record<string, unknown>, options?: {
+        idempotent?: boolean;
+        maxRetries?: number;
+    }): Promise<T>;
+    openStream(path: string, init: {
+        signal?: AbortSignal;
+        lastEventId?: string;
+    }): Promise<Response>;
+}
+type SseFrame = {
+    id?: string;
+    event: string;
+    data: string;
+};
+/** Parses server-sent events from a byte stream. */
+declare function parseServerSentEvents(body: ReadableStream<Uint8Array>): AsyncGenerator<SseFrame>;
+type RecurringPurchaseCycleStatus = 'checking' | 'scheduled' | 'needs_review' | 'paying' | 'paid' | 'skipped' | 'missed' | 'failed' | 'cancelled';
+/** A repeat order the buyer set up while approving a purchase on Conto's hosted page. */
+interface RecurringPurchase {
+    id: string;
+    object: 'recurring_purchase';
+    buyerId: string;
+    agentId: string;
+    paymentMethodId: string;
+    environment: 'live' | 'test';
+    status: 'active' | 'paused' | 'cancelled' | 'ended';
+    merchant: {
+        name: string;
+    };
+    description: string | null;
+    request: Record<string, unknown>;
+    cadence: {
+        unit: 'day' | 'month';
+        every: number;
+        label: string;
+    };
+    limits: {
+        /** The most one order may cost and still go through without the buyer's review. */
+        maxOrderMinor: number;
+        baselineMinor: number;
+        priceToleranceBps: number;
+        currency: 'USD';
+    };
+    /** How long before each order the buyer gets a heads-up. */
+    noticeMinutes: number;
+    skipNext: boolean;
+    nextDueAt: string | null;
+    expiresAt: string;
+    createdAt: string;
+    endedAt: string | null;
+    cycles: Array<{
+        cycleKey: string;
+        status: RecurringPurchaseCycleStatus;
+        purchaseId: string | null;
+        payAt: string | null;
+        total: {
+            amountMinor: number;
+            currency: string;
+        } | null;
+        createdAt: string;
+    }>;
+}
+interface RecurringPurchaseCycleResult {
+    recurrence: RecurringPurchase;
+    cycle: {
+        cycleKey: string;
+        status: RecurringPurchaseCycleStatus;
+        purchaseId: string | null;
+    };
+    /** The order's purchase when this call started it. Follow it like any purchase. */
+    purchase?: Purchase;
+    created: boolean;
+}
+/**
+ * Repeat orders. The buyer sets one up while approving a purchase. The agent
+ * starts each order with a cycle key that names it, such as `2026-W41`, so a
+ * retry never orders twice. Conto sends the buyer a heads-up and pays at the
+ * order's payment time, or asks the buyer when the order changed.
+ */
+declare class RecurringPurchasesClient {
+    #private;
+    constructor(transport: PurchaseTransport, basePath?: string);
+    list(buyerId?: string): Promise<{
+        items: RecurringPurchase[];
+    }>;
+    get(id: string): Promise<RecurringPurchase>;
+    /** Starts one order. The same cycle key returns the same order. */
+    startCycle(id: string, cycleKey: string): Promise<RecurringPurchaseCycleResult>;
+    /** Skips one order, also before it starts. */
+    skipCycle(id: string, cycleKey: string): Promise<RecurringPurchaseCycleResult['cycle']>;
+}
+/** The organization's view of its buyers' repeat orders. It can also cancel one. */
+declare class OrganizationRecurringPurchasesClient extends RecurringPurchasesClient {
+    #private;
+    constructor(client: PurchaseTransport);
+    /** Stops a repeat order. An order waiting for its payment time closes unpaid. */
+    cancel(id: string): Promise<RecurringPurchase>;
+}
+/**
+ * The agent's purchases. Card data, browser sessions and provider handles
+ * never appear here. Actions the agent may not complete (review, approval,
+ * card verification) are refused by the API and carry a Conto page `url`.
+ */
+declare class PurchasesClient {
+    #private;
+    constructor(transport: PurchaseTransport, basePath?: string);
+    /**
+     * Starts a purchase and returns at once. Reusing the idempotency key with the
+     * same input returns the same purchase, so retrying after a lost response is safe.
+     */
+    create(input: CreatePurchaseInput, options: {
+        idempotencyKey: string;
+    }): Promise<Purchase>;
+    list(params?: {
+        limit?: number;
+        offset?: number;
+        status?: PurchaseStatus;
+    }): Promise<PurchaseList>;
+    get(id: string): Promise<Purchase>;
+    /**
+     * Answers an open action whose authority is `agent_or_buyer` with the fields
+     * it lists. The acknowledgment means recorded; the purchase shows the result.
+     * The same answer again returns the same acknowledgment.
+     */
+    respond(id: string, input: {
+        actionId: string;
+        fields: Record<string, unknown>;
+        revision?: number;
+    }): Promise<PurchaseResponseAck>;
+    events(id: string, params?: {
+        after?: number;
+        limit?: number;
+    }): Promise<PurchaseEventPage>;
+    /**
+     * Requests cancellation. Before payment the purchase stops. Once payment may
+     * have been submitted, `cancellationOutcome` is `too_late` and the purchase
+     * stays in reconciliation. Nothing is refunded by this call.
+     */
+    cancel(id: string): Promise<Purchase & {
+        cancellationOutcome: CancellationOutcome;
+    }>;
+    /**
+     * Yields the purchase's events in version order until it reaches a final
+     * status. Streams with server-sent events and reconnects from the last
+     * version; falls back to polling where streaming is unavailable. A duplicate
+     * after a reconnect is dropped. A `purchase.resync` event carries the
+     * current purchase when the cursor could not be resumed.
+     */
+    watch(id: string, options?: WatchPurchaseOptions): AsyncGenerator<PurchaseEvent>;
+}
+interface PurchaseBuyer {
+    id: string;
+    object: 'buyer';
+    externalId: string;
+    agentId: string;
+    status: 'active' | 'stopped';
+    limits: {
+        perPurchaseMinor: number;
+        dailyMinor: number;
+        currency: 'USD';
+        confirmed: boolean;
+    };
+    createdAt: string;
+}
+interface PurchasePaymentMethod {
+    id: string;
+    object: 'payment_method';
+    buyerId: string;
+    type: 'card';
+    environment: 'live' | 'test';
+    brand: string;
+    last4: string;
+    status: 'active' | 'removed';
+    createdAt: string;
+}
+interface PurchaseDelegation {
+    id: string;
+    object: 'delegation';
+    buyerId: string;
+    agentId: string;
+    paymentMethodId: string;
+    status: 'active' | 'revoked';
+    scope: 'merchant_bound_single_use';
+    limits: {
+        perPurchaseMinor: number;
+        dailyMinor: number;
+        currency: 'USD';
+    };
+    requiresPurchaseReview: true;
+    requiresCardVerification: boolean;
+    createdAt: string;
+    revokedAt: string | null;
+}
+interface PurchaseHostedLink {
+    id: string;
+    object: 'hosted_link';
+    purpose: 'setup' | 'purchase';
+    buyerId: string;
+    purchaseId: string | null;
+    /** Single use. Send the buyer here. Expires in 10 minutes. */
+    url: string;
+    expiresAt: string;
+}
+interface PurchasingCapabilities {
+    object: 'purchasing_capabilities';
+    /** Test mode is open to every organization. Live needs Conto to enable it. */
+    environments: Record<'test' | 'live', {
+        available: boolean;
+        reason?: string;
+    }>;
+    currencies: string[];
+    cardNetworks: string[];
+    executors: Array<{
+        executor: string;
+        available: boolean;
+        [key: string]: unknown;
+    }>;
+    /** Whether buyers can let their agent buy at a store without review, per environment. */
+    allowances?: Record<'test' | 'live', {
+        available: boolean;
+    }>;
+    unsupported: Array<{
+        capability: string;
+        reason: string;
+    }>;
+}
+/** The organization client's transport. Same shape as the agent client's. */
+type AdminTransport = PurchaseTransport;
+/** The organization's purchases. Adds buyer filtering and hosted action links. */
+declare class OrganizationPurchasesClient extends PurchasesClient {
+    #private;
+    constructor(client: AdminTransport);
+    list(params?: {
+        limit?: number;
+        offset?: number;
+        status?: PurchaseStatus;
+        buyerId?: string;
+    }): Promise<PurchaseList>;
+    /** A single-use link that opens the purchase's buyer actions on Conto's hosted page. */
+    createActionLink(id: string, input?: {
+        returnUrl?: string;
+    }): Promise<PurchaseHostedLink>;
+}
+/**
+ * Buyers, hosted setup, payment methods, delegations and purchase oversight.
+ * Only a buyer on Conto's hosted page can add a card or create a delegation.
+ */
+declare class AdminPurchasingClient {
+    #private;
+    constructor(client: AdminTransport);
+    /** Buyers' repeat orders: list, read, start or skip an order, and cancel. */
+    readonly recurringPurchases: OrganizationRecurringPurchasesClient;
+    readonly buyers: {
+        /** Maps one of your users to a buyer with its own agent, or returns the existing one. */
+        create: (input: {
+            externalId: string;
+            email: string;
+        }) => Promise<PurchaseBuyer>;
+        get: (id: string) => Promise<PurchaseBuyer>;
+        list: (params?: {
+            limit?: number;
+            offset?: number;
+        }) => Promise<{
+            items: PurchaseBuyer[];
+            total: number;
+            limit: number;
+            offset: number;
+        }>;
+        /** Stops the buyer's agent. Purchases that may already be paid stay visible. */
+        stop: (id: string) => Promise<PurchaseBuyer>;
+    };
+    readonly paymentMethods: {
+        /** A single-use link to the hosted setup page: limits, card and delegation. */
+        createSetupLink: (input: {
+            buyerId: string;
+            returnUrl?: string;
+            environment?: "live" | "test";
+        }) => Promise<PurchaseHostedLink>;
+        list: (buyerId: string) => Promise<{
+            items: PurchasePaymentMethod[];
+        }>;
+        remove: (id: string) => Promise<{
+            id: string;
+            removed: true;
+        }>;
+    };
+    readonly delegations: {
+        list: (buyerId: string) => Promise<{
+            items: PurchaseDelegation[];
+        }>;
+        get: (id: string) => Promise<PurchaseDelegation>;
+        revoke: (id: string) => Promise<PurchaseDelegation>;
+    };
+    /**
+     * Purchases with the organization key: start one for a buyer, answer its
+     * ordinary forms, follow it and cancel it, with the same methods as the
+     * agent client. Buyer actions open on Conto's hosted page from `createActionLink`.
+     */
+    readonly purchases: OrganizationPurchasesClient;
+    readonly settings: {
+        get: () => Promise<{
+            allowedReturnOrigins: string[];
+        }>;
+        update: (input: {
+            allowedReturnOrigins: string[];
+        }) => Promise<{
+            allowedReturnOrigins: string[];
+        }>;
+    };
+    /** What this organization can run now: test mode always, live once Conto enables it. */
+    capabilities(): Promise<PurchasingCapabilities>;
+}
+/**
+ * Verifies a purchase webhook. Pass the raw request body exactly as received,
+ * the X-Conto-Signature header and your organization's webhook signing secret.
+ * Refuses a bad signature and a delivery older than the tolerance. Deduplicate
+ * on the returned deliveryId, which is the same on every retry.
+ */
+declare function verifyPurchaseWebhook(input: {
+    body: string;
+    signature: string | null | undefined;
+    secret: string;
+    toleranceSeconds?: number;
+    now?: Date;
+}): {
+    event: string;
+    timestamp: string;
+    deliveryId: string;
+    data: PurchaseEvent;
+};
+
 interface ApiErrorMetadata {
     code: string;
     status: number;
@@ -638,40 +1148,6 @@ interface RollbackPolicyVersionResponse extends Policy {
     restoredFromVersion: number;
     newVersion: number | null;
 }
-type StripeLinkCheckoutReadinessStatus = 'NOT_READY' | 'READY_FOR_VERIFICATION' | 'VERIFIED' | 'VERIFICATION_FAILED';
-type StripeLinkCheckoutVerification = 'NOT_RUN' | 'NOT_READY' | 'VERIFIED' | 'ACCOUNT_MISMATCH' | 'PROVIDER_UNAVAILABLE';
-/**
- * Non-identifying readiness projection for the configured Stripe Link
- * Checkout adapter. Merchant/account identifiers, URLs, credentials, hashes,
- * Stripe objects, and raw provider errors are intentionally absent.
- */
-interface StripeLinkCheckoutReadiness {
-    readonly status: StripeLinkCheckoutReadinessStatus;
-    readonly mode: 'TEST' | 'LIVE' | null;
-    readonly checks: {
-        readonly providerEnabled: boolean;
-        readonly checkoutEnabled: boolean;
-        readonly organizationAllowed: boolean;
-        readonly configurationValid: boolean;
-        readonly accountVerified: boolean;
-    };
-    readonly canVerify: boolean;
-    readonly verifiedAt: string | null;
-    readonly verification: StripeLinkCheckoutVerification;
-    readonly scope: {
-        readonly configuredMerchantCheckoutOnly: true;
-        readonly statement: string;
-    };
-    readonly link: {
-        readonly eligibilityGuaranteed: false;
-        readonly displayGuaranteed: false;
-        readonly selectionGuaranteed: false;
-        readonly statement: string;
-    };
-}
-interface StripeLinkCheckoutReadinessResult {
-    readonly readiness: StripeLinkCheckoutReadiness;
-}
 declare class ContoAdmin {
     #private;
     private baseUrl;
@@ -681,21 +1157,25 @@ declare class ContoAdmin {
     cards: AdminCardsClient;
     policies: PoliciesClient;
     team: TeamClient;
-    paymentRails: PaymentRailsClient;
+    /** Buyers, hosted setup, payment methods, delegations and purchases. */
+    purchasing: AdminPurchasingClient;
     constructor(config: ContoAdminConfig);
-    /** Make an authenticated request to the Conto API */
-    request<T>(method: string, path: string, body?: Record<string, unknown>): Promise<T>;
-}
-declare class PaymentRailsClient {
-    private client;
-    constructor(client: ContoAdmin);
-    /** Read gate and configuration readiness without calling Stripe. */
-    getStripeLinkCheckoutReadiness(): Promise<StripeLinkCheckoutReadinessResult>;
     /**
-     * Ask Conto to verify that its configured Stripe credential resolves to its
-     * configured merchant account. This call never returns either identifier.
+     * Opens an authenticated server-sent event stream. Used by
+     * `purchasing.purchases.watch()`. The server closes it after about 50 seconds.
+     * @internal
+     */
+    openStream(path: string, init?: {
+        signal?: AbortSignal;
+        lastEventId?: string;
+    }): Promise<Response>;
+    /**
+     * Make an authenticated request to the Conto API. Reads retry. A write retries
+     * only when `idempotent` says the API deduplicates it, as purchase creation does.
      */
-    verifyStripeLinkCheckoutAccount(): Promise<StripeLinkCheckoutReadinessResult>;
+    request<T>(method: string, path: string, body?: Record<string, unknown>, options?: {
+        idempotent?: boolean;
+    }): Promise<T>;
 }
 declare class AdminCardsClient {
     private client;
@@ -992,8 +1472,6 @@ interface ContoConfig {
     baseUrl?: string;
     /** Request timeout in milliseconds. Defaults to 30000 */
     timeout?: number;
-    /** Defaults for the configured live Link checkout pilot. These are IDs, never Link credentials. */
-    link?: LinkPaymentDefaults;
 }
 interface PaymentRequestInput {
     /** Amount in the wallet chain stablecoin */
@@ -1227,7 +1705,7 @@ interface PaymentRequestResult {
     /** Unique request ID - use this to execute or check status */
     requestId: string;
     /** Current status */
-    status: 'APPROVED' | 'DENIED' | 'REQUIRES_APPROVAL' | 'PROCESSING';
+    status: 'APPROVED' | 'DENIED' | 'REQUIRES_APPROVAL' | 'PROCESSING' | 'COMPLETED';
     /** Requested amount */
     amount: number;
     /** Currency selected for the payment */
@@ -1527,6 +2005,23 @@ interface ConnectedCardDrawResult {
     /** Provider expiration of the one-time credential; present with a fresh credential. */
     credentialExpiresAt?: string;
 }
+/**
+ * What happened with a card number the agent received. `USED` with no
+ * `amountMinor` means the full approved amount.
+ */
+interface ConnectedCardOutcomeReport {
+    outcome: 'USED' | 'NOT_USED';
+    /** `USED` only: the amount charged in USD cents, at most the approved amount. */
+    amountMinor?: number;
+}
+interface ConnectedCardOutcomeReportResult {
+    recorded: true;
+    /** True when the report closed the draw: used at the full approved amount. */
+    closed: boolean;
+    /** True when a person must confirm before any held amount is released. */
+    reviewRequired: boolean;
+    settlementVerified: false;
+}
 interface ConnectedCardMandateMerchant {
     name: string | null;
     categoryCode: string | null;
@@ -1666,21 +2161,6 @@ interface TestCheckoutResult extends TestCardReceipt {
     replayed: boolean;
     status: 'COMPLETED';
 }
-interface StripeLinkPaymentMethod {
-    id: string;
-    type: string;
-    isDefault: boolean;
-    displayLabel: string;
-    last4?: string;
-    eligibleCredentialTypes: string[];
-}
-interface ListStripeLinkPaymentMethodsResult {
-    /** Authenticated tenant context, returned so operators can verify a target before writes. */
-    organizationId: string;
-    connectionId: string;
-    /** Masked Link payment methods eligible for the bound agent. */
-    paymentMethods: StripeLinkPaymentMethod[];
-}
 type CommerceTotalType = 'subtotal' | 'tax' | 'total' | 'items_base_amount' | 'items_discount' | 'discount' | 'fulfillment' | 'shipping' | 'fee' | 'gift_wrap' | 'tip' | 'store_credit';
 interface CommerceLineItemInput {
     name: string;
@@ -1705,8 +2185,8 @@ interface CommerceFulfillmentInput {
     countryCode?: string;
 }
 type CheckoutCheckpointMethod = 'LINK' | 'CARD' | 'SHOP_PAY' | 'PAYPAL';
-type CheckoutCheckpointStage = 'APPROVED' | 'CONFIRMING' | 'CONFIRMED' | 'PAID' | 'NOT_PAID' | 'OUTCOME_UNKNOWN' | 'DENIED' | 'CANCELLED' | 'EXPIRED';
-type CheckoutCheckpointNextAction = 'CONFIRM_BEFORE_PAYING' | 'PAY_THEN_REPORT_OUTCOME' | 'REPORT_OUTCOME' | 'WAIT' | 'NONE';
+type CheckoutCheckpointStage = 'AWAITING_APPROVAL' | 'APPROVED' | 'CONFIRMING' | 'CONFIRMED' | 'PAID' | 'NOT_PAID' | 'OUTCOME_UNKNOWN' | 'DENIED' | 'CANCELLED' | 'EXPIRED';
+type CheckoutCheckpointNextAction = 'WAIT_FOR_APPROVAL' | 'CONFIRM_BEFORE_PAYING' | 'PAY_THEN_REPORT_OUTCOME' | 'REPORT_OUTCOME' | 'WAIT' | 'NONE';
 type CheckoutOutcome = 'PAID' | 'NOT_PAID' | 'UNKNOWN';
 /** First checkpoint: the purchase as the checkout shows it before the payment method opens. */
 interface BeginCheckoutCheckpointInput {
@@ -1765,11 +2245,27 @@ interface CheckoutCheckpoint {
         lineItems: CommerceLineItemInput[];
         totals: CommerceTotalInput[];
     };
+    /** While AWAITING_APPROVAL, when the owner's decision window closes. Otherwise when the approval lapses. */
     expiresAt: string;
+    /** Present when the agent's rules sent this purchase to the owner for approval. */
+    approval?: CheckoutCheckpointApproval;
     outcomeReference?: string;
     /** Outcomes are reported by your checkout. Conto does not verify settlement here. */
     settlementVerified: false;
 }
+interface CheckoutCheckpointApproval {
+    requestId: string;
+    status: 'PENDING' | 'APPROVED' | 'DENIED' | 'EXPIRED' | 'CANCELLED';
+    /** Set while PENDING. */
+    expiresAt?: string;
+}
+interface WaitForCheckoutApprovalOptions {
+    /** Stop waiting after this long. Defaults to 10 minutes. The spend stays held until you cancel. */
+    timeoutMs?: number;
+    /** Time between status reads. Defaults to 5 seconds, minimum 1 second. */
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+}
 /** Exact Stripe Link purchase intent evaluated and bound by Conto policy. */
 interface BeginCommerceExecutionCommonInput {
     /** Stable key for this exact intent. Reuse it when reconciling or retrying begin. */
@@ -1861,66 +2357,6 @@ type BeginCommerceExecutionInput = (BeginConnectedLinkExecutionInput & {
         checkoutUrl: string;
     };
 });
-/** Configuration inspection only: no policy evaluation, credential retrieval, or purchase. */
-interface LinkSetupInput {
-    connectionId?: string;
-    paymentMethodId?: string;
-    merchantId?: string;
-}
-interface LinkSetupCheck {
-    code: string;
-    status: 'PASS' | 'BLOCKED' | 'WARNING';
-    actor: 'developer' | 'owner' | 'operator';
-    message: string;
-}
-interface LinkSetupResult {
-    version: 'conto.link-setup.v1';
-    mode: 'LIVE' | 'SIMULATED';
-    configurationStatus: 'CONFIGURED' | 'INCOMPLETE';
-    checks: LinkSetupCheck[];
-    missingScopes: string[];
-    checkout?: {
-        merchantId: string;
-        origin: string;
-        currency: 'USD';
-        maxAmountMinor: number;
-    };
-    paymentAuthorization: 'NOT_EVALUATED';
-    providerVerified: false;
-    settlementVerified: false;
-}
-/** Reusable owner-provisioned identifiers. Per-purchase values can override these defaults. */
-interface LinkPaymentDefaults {
-    connectionId: string;
-    paymentMethodId: string;
-}
-/** Exact purchase facts for a configured USD digital-goods checkout. */
-interface LinkPaymentInput {
-    /** Persist this key before calling pay; reuse it for this exact purchase across restarts. */
-    idempotencyKey: string;
-    connectionId?: string;
-    paymentMethodId?: string;
-    /** Canonical ID of a checkout profile already configured by the deployment operator. */
-    merchantId: string;
-    checkoutUrl: string;
-    amountMinor: number;
-    currency?: 'USD';
-    purpose: string;
-    category?: string;
-    lineItems: CommerceLineItemInput[];
-    /** Required when the final amount differs from the line-item sum. Include the exact total breakdown. */
-    totals?: CommerceTotalInput[];
-}
-type LinkPaymentNextAction = 'APPROVE_IN_LINK' | 'WAIT' | 'RESUME' | 'RECONCILE' | 'NONE';
-/** Safe payment state; submission and completion are not proof of settlement. */
-interface LinkPaymentResult extends CommerceExecutionResult {
-    executionId: string;
-    status: CommerceExecutionStatus;
-    nextAction: LinkPaymentNextAction;
-    /** Present only while Link approval is needed. Show it to the account owner. */
-    approvalUrl?: string;
-    checkout?: ExecuteCommerceExecutionResult['checkout'];
-}
 type CommerceExecutionStatus = 'DRAFT' | 'ACTION_REQUIRED' | 'AUTHORIZING' | 'AWAITING_APPROVAL' | 'READY' | 'PROCESSING' | 'SETTLED' | 'COMPLETED' | 'DENIED' | 'CANCELLED' | 'FAILED' | 'RETURNED' | 'EXPIRED' | 'NEEDS_RECONCILIATION';
 type CommerceExecutionProvider = 'STABLECOIN' | 'TOKENIZED_CARD' | 'STRIPE_LINK';
 type CommerceExecutionChannel = 'BROWSER' | 'MERCHANT_API' | 'CREDENTIAL_BROKER' | 'BANK_API' | 'WALLET_SIGNER';
@@ -2327,6 +2763,13 @@ interface MppPreAuthorizeInput {
     credentialId?: string;
     challengeId?: string;
     paymentMethod?: string;
+    /**
+     * Wallet address your MPP client pays from. Provide together with network
+     * when the agent has more than one wallet it signs with.
+     */
+    payerAddress?: string;
+    /** CAIP-2 network of payerAddress, for example eip155:42431. */
+    network?: string;
 }
 interface MppPreAuthorizeResult extends ProtocolPreAuthorizeResult {
     mpp: {
@@ -2452,12 +2895,6 @@ declare class ContoError extends Error {
     readonly diagnostics?: SetupDiagnostics;
     constructor(message: string, metadata: ApiErrorMetadata, diagnostics?: unknown);
 }
-/** Execution was attempted. Inspect this existing execution before any further payment action. */
-declare class LinkPaymentExecutionError extends ContoError {
-    readonly executionId: string;
-    readonly nextAction: "RECONCILE";
-    constructor(executionId: string, error: unknown);
-}
 /**
  * The customer executor returned a receipt, but Conto did not acknowledge the
  * confirmation. Persist confirmationInput and retry cards.confirm(); never run
@@ -2485,6 +2922,41 @@ declare class BrowserActionFinalizationPendingError<TResult = unknown> extends C
         observation: BrowserActionDispatchObservationInput;
     });
 }
+/**
+ * The checkpoint is closed and approves nothing: denied, cancelled, expired, or
+ * reported not paid. Stop this checkout. Start a new purchase with a new
+ * idempotency key if the buyer still wants it.
+ */
+declare class CheckoutCheckpointClosedError extends ContoError {
+    readonly checkpoint: CheckoutCheckpoint;
+    readonly stage: CheckoutCheckpointStage;
+    constructor(checkpoint: CheckoutCheckpoint, message?: string, code?: string);
+}
+/** The owner rejected this purchase. Its spend was released. Do not pay. */
+declare class CheckoutApprovalDeniedError extends CheckoutCheckpointClosedError {
+    constructor(checkpoint: CheckoutCheckpoint);
+}
+/** The owner did not decide before the approval expired. Its spend was released. Do not pay. */
+declare class CheckoutApprovalExpiredError extends CheckoutCheckpointClosedError {
+    constructor(checkpoint: CheckoutCheckpoint);
+}
+/**
+ * The owner has not approved this purchase yet. Do not pay. Wait with
+ * waitForApproval(error.checkpoint), then confirm the approved checkpoint, or
+ * cancel it to release the spend.
+ */
+declare class CheckoutApprovalPendingError extends ContoError {
+    readonly checkpoint: CheckoutCheckpoint;
+    constructor(checkpoint: CheckoutCheckpoint);
+}
+/**
+ * waitForApproval stopped before the owner decided. The spend is still held:
+ * wait again, or cancel the checkpoint to release it.
+ */
+declare class CheckoutApprovalTimeoutError extends ContoError {
+    readonly checkpoint: CheckoutCheckpoint;
+    constructor(checkpoint: CheckoutCheckpoint);
+}
 interface ContoRequestOptions {
     /** Set only when repeating this request cannot create an additional side effect. */
     idempotent?: boolean;
@@ -2495,7 +2967,6 @@ declare class Conto {
     #private;
     private baseUrl;
     private timeout;
-    link: LinkClient;
     /** Lightweight checkpoints before the payment method opens and before payment. */
     checkout: CheckoutClient;
     payments: PaymentsClient;
@@ -2504,17 +2975,11 @@ declare class Conto {
     testCards: TestCardsClient;
     x402: X402Client;
     mpp: MppClient;
+    /** Purchases from a product URL and task to a merchant-confirmed order. */
+    purchases: PurchasesClient;
+    /** Repeat orders the agent's buyer set up. The agent starts each order. */
+    recurringPurchases: RecurringPurchasesClient;
     constructor(config: ContoConfig);
-    /**
-     * List masked Link payment methods for a session-created connection that is
-     * explicitly bound to this agent. No Link token or payment artifact is
-     * returned through the agent SDK.
-     */
-    listStripeLinkPaymentMethods(connectionId: string, options?: {
-        mode?: 'TEST' | 'LIVE';
-    }): Promise<ListStripeLinkPaymentMethodsResult>;
-    /** Read live Link configuration diagnostics without retrieving credentials or authorizing payment. */
-    getLinkSetup(input?: LinkSetupInput): Promise<LinkSetupResult>;
     /**
      * Normalize and durably revise a partial agent purchase proposal without
      * creating a payment side effect. Missing facts return as NEEDS_CONTEXT
@@ -2532,6 +2997,12 @@ declare class Conto {
     beginCommerceExecution(input: BeginCommerceExecutionInput): Promise<CommerceExecutionResult>;
     /** Atomically consume the Conto authorization for one exact browser action. */
     authorizeCheckoutAction(executionId: string, browserSessionId: string, action: AgentCheckoutAction | BrowserCheckoutAction): Promise<AuthorizeCheckoutActionResult>;
+    /**
+     * Report whether an authorized guarded browser checkout was paid. PAID keeps
+     * the held spend counted, NOT_PAID releases it, and UNKNOWN keeps it held for
+     * the owner to review. Safe to repeat with the same outcome.
+     */
+    reportCommerceExecutionOutcome(executionId: string, input: ReportCheckoutOutcomeInput): Promise<CommerceExecutionResult>;
     /** Claim a durable browser action for one stable privileged-runtime attempt. */
     claimBrowserAction(authorizationId: string, dispatchAttemptId: string, browserSessionId: string, action: AgentCheckoutAction | BrowserCheckoutAction): Promise<BrowserActionClaimResult>;
     /** Finalize the exact dispatch attempt; this never performs the browser side effect. */
@@ -2586,6 +3057,15 @@ declare class Conto {
      * diagnostics without creating a payment.
      */
     setup(): Promise<AgentSetupResult>;
+    /**
+     * Opens an authenticated server-sent event stream. Used by
+     * `purchases.watch()`. The server closes it after about 50 seconds.
+     * @internal
+     */
+    openStream(path: string, init?: {
+        signal?: AbortSignal;
+        lastEventId?: string;
+    }): Promise<Response>;
     /** Make an authenticated request to the Conto API */
     request<T>(method: string, path: string, body?: Record<string, unknown>, options?: ContoRequestOptions): Promise<T>;
 }
@@ -2673,17 +3153,34 @@ declare class ConnectedCardsClient {
      * ```
      */
     draw(input: ConnectedCardDrawInput): Promise<ConnectedCardDrawResult>;
+    /** Record receipt after a fresh draw. Does not confirm checkout or payment settlement. */
+    acknowledgeDelivery(requestId: string): Promise<{
+        acknowledged: boolean;
+        settlementVerified: false;
+    }>;
+    /**
+     * Report what happened with the card number after checkout.
+     *
+     * `USED` at the full approved amount closes the draw. `NOT_USED`, or `USED`
+     * with a smaller `amountMinor`, is recorded and shown to a person, who
+     * confirms it before the held amount is released. A report never releases
+     * held spend by itself and does not confirm settlement. Safe to repeat with
+     * the same report. A different second report gets HTTP 409.
+     *
+     * @example
+     * ```typescript
+     * await conto.connectedCards.reportOutcome(draw.requestId, { outcome: 'USED' });
+     * await conto.connectedCards.reportOutcome(draw.requestId, { outcome: 'USED', amountMinor: 1850 });
+     * await conto.connectedCards.reportOutcome(draw.requestId, { outcome: 'NOT_USED' });
+     * ```
+     */
+    reportOutcome(requestId: string, report: ConnectedCardOutcomeReport): Promise<ConnectedCardOutcomeReportResult>;
     /**
      * List the connected cards and active mandates this agent may draw against.
      *
      * The response is masked: no PAN and no provider tokens. This is a read-only
      * GET, so transport retry on transient failures is safe.
      */
-    /** Record receipt after a fresh draw. Does not confirm checkout or payment settlement. */
-    acknowledgeDelivery(requestId: string): Promise<{
-        acknowledged: boolean;
-        settlementVerified: false;
-    }>;
     list(): Promise<ConnectedCardListResult>;
 }
 /**
@@ -2854,57 +3351,51 @@ declare class MppClient {
     }): Promise<ProtocolServicesResult>;
 }
 
-/** Narrow transport contract used by the isolated, credential-free test client. */
-type LinkCommerceClient = Pick<Conto, 'getLinkSetup' | 'listStripeLinkPaymentMethods' | 'beginCommerceExecution' | 'getCommerceExecution' | 'refreshCommerceExecution' | 'executeCommerceExecution' | 'cancelCommerceExecution'>;
 /**
  * Lightweight checkout checkpoints for any agent runtime. Call begin() before the
  * payment method opens and confirm() right before the payment is submitted. Pay
  * only after confirm() succeeds, then report the outcome. Conto decides and
  * records each step; your checkout enforces the answer.
+ *
+ * When the agent's rules require approval, begin() returns stage
+ * AWAITING_APPROVAL with the spend held. Do not open the payment method yet:
+ * call waitForApproval() and continue with the checkpoint it returns.
  */
 declare class CheckoutClient {
     #private;
     constructor(client: Pick<Conto, 'request'>);
-    /** First checkpoint. A ContoError means Conto did not approve: stop the checkout. */
+    /**
+     * First checkpoint. Open the payment method only when the stage is APPROVED.
+     * AWAITING_APPROVAL means the owner must decide first: call waitForApproval().
+     * A ContoError means Conto did not approve: stop the checkout. A
+     * CheckoutCheckpointClosedError means this idempotency key belongs to a
+     * checkpoint that already closed.
+     */
     begin(input: BeginCheckoutCheckpointInput): Promise<CheckoutCheckpoint>;
+    /**
+     * Waits while the owner decides on a checkpoint in AWAITING_APPROVAL and
+     * resolves to the approved checkpoint. Throws CheckoutApprovalDeniedError,
+     * CheckoutApprovalExpiredError, CheckoutCheckpointClosedError, or
+     * CheckoutApprovalTimeoutError (the spend stays held until you cancel).
+     */
+    waitForApproval(checkpoint: CheckoutCheckpoint, options?: WaitForCheckoutApprovalOptions): Promise<CheckoutCheckpoint>;
     /**
      * Second checkpoint, right before the payment is submitted. If the total
      * changed since begin() (tax or shipping, for example), this cancels the
      * approved checkpoint and starts a new one at the final total, so the agent's
-     * rules see the amount actually being paid. Pay only if this resolves.
+     * rules see the amount actually being paid. Pay only if this resolves. A
+     * CheckoutApprovalPendingError means the owner must approve first: call
+     * waitForApproval(error.checkpoint), then confirm the checkpoint it returns.
      */
     confirm(checkpoint: CheckoutCheckpoint, input: ConfirmCheckoutCheckpointInput): Promise<CheckoutCheckpoint>;
     /** Report what happened after a confirmed checkpoint. Safe to repeat with the same outcome. */
     reportOutcome(checkpointId: string, input: ReportCheckoutOutcomeInput): Promise<CheckoutCheckpoint>;
-    /** Cancel a checkpoint that was not confirmed and release its spend. */
-    cancel(checkpointId: string): Promise<CheckoutCheckpoint>;
-    get(checkpointId: string): Promise<CheckoutCheckpoint>;
-}
-declare class LinkClient {
-    #private;
-    constructor(client: LinkCommerceClient, defaults?: LinkPaymentDefaults);
-    /** Inspect the configured live path. This is not a payment authorization or provider connectivity test. */
-    setup(input?: LinkSetupInput): Promise<LinkSetupResult>;
-    /** Read masked LIVE funding sources; never selects a source or initiates payment. */
-    paymentMethods(connectionId?: string): Promise<ListStripeLinkPaymentMethodsResult>;
     /**
-     * Begin one exact intent and execute only if already READY. Otherwise return
-     * the owner's approval action or existing state immediately, without polling.
+     * Cancel a checkpoint that was not confirmed and release its spend. A
+     * checkpoint waiting for the owner can be cancelled too.
      */
-    pay(input: LinkPaymentInput): Promise<LinkPaymentResult>;
-    /**
-     * Continue the existing payment after approval. Reads before any mutation and
-     * never submits an execution already processing or requiring reconciliation.
-     */
-    resume(executionId: string): Promise<LinkPaymentResult>;
-    /** Observe and reconcile provider state. This method never submits a payment. */
-    status(executionId: string): Promise<LinkPaymentResult>;
-    /** Request cancellation of this existing Link payment; never retried automatically. */
-    cancel(executionId: string): Promise<LinkPaymentResult>;
-    private identifier;
-    private assertLinkExecution;
-    private executeIfReady;
-    private result;
+    cancel(checkpointId: string): Promise<CheckoutCheckpoint>;
+    get(checkpointId: string): Promise<CheckoutCheckpoint>;
 }
 
-export { type AdminExternalCardOverlayEnforcement, type Agent, type AgentCheckoutAction, type AgentCheckoutActionKind, type AgentExternalCard, type AgentSetupResult, type AgentStatus, type AgentType, type AgentWalletLink, type ApprovedExternalCardExecution, type AssignExternalCardInput, type AssignedPolicy, type AuthorizeCheckoutActionResult, type BeginCheckoutCheckpointInput, type BeginCommerceExecutionInput, type BrowserActionClaimResult, type BrowserActionDispatchObservationInput, BrowserActionFinalizationPendingError, type BrowserActionFinalizeResult, type BrowserCheckoutAction, type BrowserCheckoutTargetResolver, type BrowserCheckoutTargetSnapshot, type BrowserCheckoutTargetVerificationCode, BrowserCheckoutTargetVerificationError, type CanonicalBrowserCheckoutTargetSnapshot, CardsClient, type ChainType, type CheckoutActionAuthorization, type CheckoutCheckpoint, type CheckoutCheckpointMethod, type CheckoutCheckpointNextAction, type CheckoutCheckpointStage, CheckoutClient, type CheckoutOutcome, type CommerceCheckoutMethod, type CommerceContextRequirement, type CommerceExecution, type CommerceExecutionAdapterKind, type CommerceExecutionArtifactKind, type CommerceExecutionChannel, type CommerceExecutionConstraint, type CommerceExecutionConstraintCoverage, type CommerceExecutionConstraintCoverageLevel, type CommerceExecutionDeliveryMode, type CommerceExecutionEvidence, type CommerceExecutionProvider, type CommerceExecutionResult, type CommerceExecutionSourceKind, type CommerceExecutionStatus, type CommerceFactConfidence, type CommerceFactProvenanceInput, type CommerceFactSource, type CommerceFulfillmentInput, type CommerceLineItemInput, type CommerceProposalFactKey, type CommerceProposalMissingFact, type CommerceProposalResolution, type CommerceProposalState, type CommerceSettlementRail, type CommerceTotalInput, type CommerceTotalType, type ComparePolicyVersionsResponse, type ConfirmCheckoutCheckpointInput, type ConnectedCardBrief, type ConnectedCardCredential, type ConnectedCardDrawInput, type ConnectedCardDrawMerchant, type ConnectedCardDrawResult, type ConnectedCardDrawable, type ConnectedCardListResult, type ConnectedCardMandate, type ConnectedCardMandateMerchant, type ConnectedCardReference, ConnectedCardsClient, Conto, ContoAdmin, type ContoAdminConfig, ContoAdminError, type ContoConfig, ContoError, type ContoRequestOptions, type ControlledExternalCardPaymentResult, ControlledExternalCardPaymentTool, type CreateAgentInput, type CreatePolicyInput, type CreatePolicyRuleInput, type CreateSdkKeyInput, type CreateSdkKeyResult, type CreateWalletInput, type CustodyType, type CustomerCustodyMode, type CustomerWalletControlModel, type CustomerWalletKeyAccess, type DelegationType, type ExecuteCommerceExecutionResult, type ExternalCard, type ExternalCardApprovalInput, type ExternalCardApprovalResult, type ExternalCardConfirmationInput, ExternalCardConfirmationPendingError, type ExternalCardConfirmationResult, type ExternalCardExecutionClaimResult, type ExternalCardExecutionResult, type ExternalCardExecutor, type ExternalCardOverlayEnforcement, type ExternalCardRequestStatusResult, type ExternalWalletApprovalInput, type ExternalWalletApprovalResult, type ExternalWalletConfirmationInput, type ExternalWalletConfirmationResult, type FreezeAgentInput, Conto as Giro, type ContoConfig as GiroConfig, ContoError as GiroError, type GuardCheckoutResult, type GuardedBrowserDispatchResult, type GuardedCheckoutInput, LinkClient, type LinkCommerceClient, type LinkPaymentDefaults, LinkPaymentExecutionError, type LinkPaymentInput, type LinkPaymentNextAction, type LinkPaymentResult, type LinkSetupCheck, type LinkSetupInput, type LinkSetupResult, type LinkWalletInput, type ListAgentsParams, type ListAgentsResponse, type ListPoliciesParams, type ListPoliciesResponse, type ListPolicyVersionsResponse, type ListStripeLinkPaymentMethodsResult, type ListWalletsParams, type ListWalletsResponse, type MppBudgetResult, type MppPreAuthorizeInput, type MppPreAuthorizeResult, type MppRecordInput, type MppRecordResult, type NormalizeCommerceProposalInput, type OrganizationMember, type PaginatedResponse, type PaginationParams, type PauseExternalCardAssignmentResult, type PaymentExecuteResult, type PaymentRequestInput, type PaymentRequestResult, type PaymentStatusResult, type Policy, type PolicyRule, type PolicyType, type PolicyVersionChangeType, type PolicyVersionDetail, type PolicyVersionDiff, type PolicyVersionFieldChange, type PolicyVersionSnapshot, type PolicyVersionSnapshotRule, type PolicyVersionSummary, type PrivilegedBrowserCheckoutDriver, type ProtocolBudgetResult, type ProtocolPreAuthorizeResult, type ProtocolRecordGrant, type ProtocolRecordGrantResult, type ProtocolServiceSummary, type ProtocolServicesResult, type ProvisionWalletResult, type RefreshBalanceResult, type RegisterExternalCardInput, type ReportCheckoutOutcomeInput, type RollbackPolicyVersionResponse, type RuleAction, type RuleOperator, type RuleType, type RunGuardedCheckoutResult, type SdkKey, type SdkKeyType, type SetupCapabilityState, type SetupCardDiagnostics, type SetupDiagnosticAction, type SetupDiagnosticIssue, type SetupDiagnosticIssueCode, type SetupDiagnostics, type SetupWalletDiagnostics, type StripeLinkCheckoutReadiness, type StripeLinkCheckoutReadinessResult, type StripeLinkCheckoutReadinessStatus, type StripeLinkCheckoutVerification, type StripeLinkPaymentMethod, type TestCardCredential, type TestCardDrawResult, type TestCardDrawable, type TestCardListResult, type TestCardReceipt, TestCardsClient, type TestCheckoutInput, type TestCheckoutResult, type TestMerchant, type TestMerchantProduct, type UnfreezeAgentInput, type UpdateAgentInput, type UpdateExternalCardAssignmentInput, type UpdatePolicyInput, type UpdatePolicyRuleInput, type UpdateWalletInput, type VerifiedBrowserCheckoutTarget, type Wallet, type WalletChainBalanceSnapshot, type WalletStatus, type WalletType, type X402Authorization, type X402BudgetResult, type X402PayInput, type X402PayResult, type X402PaymentRequirements, type X402PreAuthorizeInput, type X402PreAuthorizeResult, type X402RecordInput, type X402RecordResult, canonicalizeBrowserCheckoutTarget, createVerifiedBrowserCheckoutDriver, Conto as default, fingerprintBrowserCheckoutTarget };
+export { type AdminExternalCardOverlayEnforcement, AdminPurchasingClient, type Agent, type AgentCheckoutAction, type AgentCheckoutActionKind, type AgentExternalCard, type AgentSetupResult, type AgentStatus, type AgentType, type AgentWalletLink, type ApprovedExternalCardExecution, type AssignExternalCardInput, type AssignedPolicy, type AuthorizeCheckoutActionResult, type BeginCheckoutCheckpointInput, type BeginCommerceExecutionInput, type BrowserActionClaimResult, type BrowserActionDispatchObservationInput, BrowserActionFinalizationPendingError, type BrowserActionFinalizeResult, type BrowserCheckoutAction, type BrowserCheckoutTargetResolver, type BrowserCheckoutTargetSnapshot, type BrowserCheckoutTargetVerificationCode, BrowserCheckoutTargetVerificationError, type CancellationOutcome, type CanonicalBrowserCheckoutTargetSnapshot, CardsClient, type ChainType, type CheckoutActionAuthorization, CheckoutApprovalDeniedError, CheckoutApprovalExpiredError, CheckoutApprovalPendingError, CheckoutApprovalTimeoutError, type CheckoutCheckpoint, type CheckoutCheckpointApproval, CheckoutCheckpointClosedError, type CheckoutCheckpointMethod, type CheckoutCheckpointNextAction, type CheckoutCheckpointStage, CheckoutClient, type CheckoutOutcome, type CommerceCheckoutMethod, type CommerceContextRequirement, type CommerceExecution, type CommerceExecutionAdapterKind, type CommerceExecutionArtifactKind, type CommerceExecutionChannel, type CommerceExecutionConstraint, type CommerceExecutionConstraintCoverage, type CommerceExecutionConstraintCoverageLevel, type CommerceExecutionDeliveryMode, type CommerceExecutionEvidence, type CommerceExecutionProvider, type CommerceExecutionResult, type CommerceExecutionSourceKind, type CommerceExecutionStatus, type CommerceFactConfidence, type CommerceFactProvenanceInput, type CommerceFactSource, type CommerceFulfillmentInput, type CommerceLineItemInput, type CommerceProposalFactKey, type CommerceProposalMissingFact, type CommerceProposalResolution, type CommerceProposalState, type CommerceSettlementRail, type CommerceTotalInput, type CommerceTotalType, type ComparePolicyVersionsResponse, type ConfirmCheckoutCheckpointInput, type ConnectedCardBrief, type ConnectedCardCredential, type ConnectedCardDrawInput, type ConnectedCardDrawMerchant, type ConnectedCardDrawResult, type ConnectedCardDrawable, type ConnectedCardListResult, type ConnectedCardMandate, type ConnectedCardMandateMerchant, type ConnectedCardOutcomeReport, type ConnectedCardOutcomeReportResult, type ConnectedCardReference, ConnectedCardsClient, Conto, ContoAdmin, type ContoAdminConfig, ContoAdminError, type ContoConfig, ContoError, type ContoRequestOptions, type ControlledExternalCardPaymentResult, ControlledExternalCardPaymentTool, type CreateAgentInput, type CreatePolicyInput, type CreatePolicyRuleInput, type CreatePurchaseInput, type CreateSdkKeyInput, type CreateSdkKeyResult, type CreateWalletInput, type CustodyType, type CustomerCustodyMode, type CustomerWalletControlModel, type CustomerWalletKeyAccess, type DelegationType, type ExecuteCommerceExecutionResult, type ExternalCard, type ExternalCardApprovalInput, type ExternalCardApprovalResult, type ExternalCardConfirmationInput, ExternalCardConfirmationPendingError, type ExternalCardConfirmationResult, type ExternalCardExecutionClaimResult, type ExternalCardExecutionResult, type ExternalCardExecutor, type ExternalCardOverlayEnforcement, type ExternalCardRequestStatusResult, type ExternalWalletApprovalInput, type ExternalWalletApprovalResult, type ExternalWalletConfirmationInput, type ExternalWalletConfirmationResult, type FreezeAgentInput, Conto as Giro, type ContoConfig as GiroConfig, ContoError as GiroError, type GuardCheckoutResult, type GuardedBrowserDispatchResult, type GuardedCheckoutInput, type LinkWalletInput, type ListAgentsParams, type ListAgentsResponse, type ListPoliciesParams, type ListPoliciesResponse, type ListPolicyVersionsResponse, type ListWalletsParams, type ListWalletsResponse, type MppBudgetResult, type MppPreAuthorizeInput, type MppPreAuthorizeResult, type MppRecordInput, type MppRecordResult, type NormalizeCommerceProposalInput, type OrganizationMember, OrganizationPurchasesClient, OrganizationRecurringPurchasesClient, type PaginatedResponse, type PaginationParams, type PauseExternalCardAssignmentResult, type PaymentExecuteResult, type PaymentRequestInput, type PaymentRequestResult, type PaymentStatusResult, type Policy, type PolicyRule, type PolicyType, type PolicyVersionChangeType, type PolicyVersionDetail, type PolicyVersionDiff, type PolicyVersionFieldChange, type PolicyVersionSnapshot, type PolicyVersionSnapshotRule, type PolicyVersionSummary, type PrivilegedBrowserCheckoutDriver, type ProtocolBudgetResult, type ProtocolPreAuthorizeResult, type ProtocolRecordGrant, type ProtocolRecordGrantResult, type ProtocolServiceSummary, type ProtocolServicesResult, type ProvisionWalletResult, type Purchase, type PurchaseAction, type PurchaseActionAuthority, type PurchaseActionKind, type PurchaseBuyer, type PurchaseDelegation, type PurchaseEvent, type PurchaseEventPage, type PurchaseEvidence, type PurchaseHostedLink, type PurchaseItem, type PurchaseList, type PurchaseMoney, type PurchasePaymentMethod, type PurchasePhase, type PurchaseResponseAck, type PurchaseStatus, PurchasesClient, type PurchasingCapabilities, type RecurringPurchase, type RecurringPurchaseCycleResult, type RecurringPurchaseCycleStatus, RecurringPurchasesClient, type RefreshBalanceResult, type RegisterExternalCardInput, type ReportCheckoutOutcomeInput, type RollbackPolicyVersionResponse, type RuleAction, type RuleOperator, type RuleType, type RunGuardedCheckoutResult, type SdkKey, type SdkKeyType, type SetupCapabilityState, type SetupCardDiagnostics, type SetupDiagnosticAction, type SetupDiagnosticIssue, type SetupDiagnosticIssueCode, type SetupDiagnostics, type SetupWalletDiagnostics, type TestCardCredential, type TestCardDrawResult, type TestCardDrawable, type TestCardListResult, type TestCardReceipt, TestCardsClient, type TestCheckoutInput, type TestCheckoutResult, type TestMerchant, type TestMerchantProduct, type UnfreezeAgentInput, type UpdateAgentInput, type UpdateExternalCardAssignmentInput, type UpdatePolicyInput, type UpdatePolicyRuleInput, type UpdateWalletInput, type VerifiedBrowserCheckoutTarget, type WaitForCheckoutApprovalOptions, type Wallet, type WalletChainBalanceSnapshot, type WalletStatus, type WalletType, type WatchPurchaseOptions, type X402Authorization, type X402BudgetResult, type X402PayInput, type X402PayResult, type X402PaymentRequirements, type X402PreAuthorizeInput, type X402PreAuthorizeResult, type X402RecordInput, type X402RecordResult, canonicalizeBrowserCheckoutTarget, createVerifiedBrowserCheckoutDriver, Conto as default, fingerprintBrowserCheckoutTarget, isFinalPurchaseStatus, parseServerSentEvents, verifyPurchaseWebhook };