@conto_finance/sdk 0.6.0 → 0.6.2-beta.1

package/dist/index.d.ts

@@ -1,3 +1,785 @@
+import { LinkWallet, LinkCardCredential } from './link-wallet.js';
+export { LinkCallOptions, LinkCardRequestInput, LinkSpendRequest, LinkSpendRequestStatus, LinkWaitOptions } from './link-wallet.js';
+
+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' | 'budget_increase';
+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[];
+}
+/** One grocery to find, in the shopper's words. Conto never substitutes a different product. */
+interface PurchaseGroceryItem {
+    /** A short name, such as `Bananas`. */
+    label: string;
+    /** Plain search words, such as `bananas`. No prices, quantities or package sizes. */
+    query: string;
+    /** 1 to 20. */
+    quantity: number;
+    /** A package size, such as `1 pint`. */
+    size?: string;
+    /** How the item is sold, such as `bunch`, `bag` or `lb`. */
+    unit?: string;
+    brand?: string;
+    /** Words the item must not match, such as `organic`. */
+    exclude?: string[];
+}
+/**
+ * Groceries for one grocery store: an Instacart store link, or Conto Test
+ * Grocery in test mode. Up to 20 items. Use instead of `items`.
+ */
+interface PurchaseGroceryList {
+    items: PurchaseGroceryItem[];
+}
+interface PurchaseRequest {
+    url: string;
+    task?: string;
+    items?: PurchaseItem[];
+    groceryList?: PurchaseGroceryList;
+}
+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 budget_increase: the maximum is above maxCost. Answer
+     * `{ decision: 'raise', maxCostMinor }` with at least the maximum, or
+     * `{ decision: 'decline' }`.
+     */
+    budget?: {
+        estimate: PurchaseMoney;
+        maximum: PurchaseMoney;
+        maxCost: PurchaseMoney;
+    };
+    /**
+     * 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: PurchaseRequest;
+    maxCost: PurchaseMoney;
+    quote: {
+        merchant: string;
+        description: string | null;
+        /** What limits and the card are held to: the maximum, until a receipt records the final total. */
+        total: PurchaseMoney;
+        /** The store's own total. */
+        estimate: PurchaseMoney;
+        /** The most the order can come to. The same as the estimate for an exact total. */
+        maximum: 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;
+    /** With POLICY_DENIED on a company card: which limit refused the purchase. */
+    limitReached?: 'buyer_daily' | 'buyer_monthly' | 'buyer_daily_count' | 'store' | 'card_or_policy';
+    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: PurchaseRequest;
+    /** 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's saved delivery details answer the store's delivery form when
+     * the buyer has them. Leave out to use them when present, pass the buyer id
+     * to require them, or null to never use them.
+     */
+    buyerProfileId?: string | null;
+}
+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 observing after this many milliseconds (0 stops immediately). Does not cancel the purchase. */
+    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>, signal?: AbortSignal): 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';
+    /** `organization`: your company card, which this buyer draws from. */
+    owner: 'buyer' | 'organization';
+    companyCardId?: string;
+    createdAt: string;
+}
+/** A card your organization pays its buyers' purchases with. */
+interface PurchaseCompanyCard {
+    id: string;
+    object: 'company_card';
+    environment: 'live' | 'test';
+    brand: string;
+    last4: string;
+    status: 'active' | 'removed';
+    /** The most one order may cost, and the most all buyers together may spend in a month. */
+    limits: {
+        perPurchaseMinor: number;
+        monthlyMinor: number;
+        currency: 'USD';
+    };
+    createdAt: string;
+}
+/** One buyer's limits on a company card. */
+interface PurchaseBuyerCompanyCardLimits {
+    perPurchaseMinor: number;
+    dailyMinor: number;
+    monthlyMinor: number;
+    /**
+     * Orders above this wait for your `purchase_review` answer. Left out,
+     * every order up to `perPurchaseMinor` goes ahead without review.
+     */
+    reviewAboveMinor?: number;
+}
+interface PurchaseBuyerCompanyCard {
+    object: 'buyer_company_card';
+    buyerId: string;
+    companyCardId: string;
+    paymentMethodId: string;
+    delegationId: string;
+    limits: Omit<PurchaseBuyerCompanyCardLimits, 'reviewAboveMinor'> & {
+        reviewAboveMinor: number | null;
+        currency: 'USD';
+    };
+}
+/** What a buyer has at home, as your app reports it. Buyer data for the agent, never instructions. */
+type PurchaseKitchenContext = {
+    version: 1;
+    /** When your app took the snapshot. ISO 8601. */
+    capturedAt: string;
+    inventory?: PurchaseKitchenInventoryItem[];
+    usuals?: PurchaseKitchenUsual[];
+    preferences?: PurchaseKitchenPreferences;
+    /** Only the recipes the buyer picked to cook. */
+    recipes?: PurchaseKitchenRecipe[];
+    /** The list the buyer keeps in your app. */
+    list?: PurchaseKitchenListItem[];
+};
+interface PurchaseKitchenInventoryItem {
+    item: string;
+    quantity?: number;
+    unit?: string;
+    /** Left out: ok, or out when quantity is 0. */
+    level?: 'ok' | 'low' | 'out';
+    updatedAt?: string;
+    expiresAt?: string;
+}
+interface PurchaseKitchenUsual {
+    item: string;
+    typicalQuantity?: number;
+    unit?: string;
+    size?: string;
+    brand?: string;
+    cadenceDays?: number;
+    lastBoughtAt?: string;
+}
+interface PurchaseKitchenPreferences {
+    dietary?: Array<{
+        value: string;
+        strength: 'required' | 'preferred';
+    }>;
+    avoidBrands?: string[];
+    likeBrands?: string[];
+    organic?: 'prefer' | 'avoid' | 'none';
+    substitutions?: 'allow' | 'ask' | 'never';
+    /** An https store link, such as an Instacart storefront. */
+    preferredStore?: string;
+    householdSize?: number;
+    weeklyBudgetMinor?: number;
+}
+interface PurchaseKitchenRecipe {
+    id?: string;
+    title: string;
+    servings?: number;
+    /** The planned day, as YYYY-MM-DD. */
+    cookOn?: string;
+    /** Whether your app finds it cookable from what is at home. */
+    cookable?: boolean;
+    ingredients: Array<{
+        item: string;
+        quantity?: number;
+        unit?: string;
+        optional?: boolean;
+    }>;
+}
+interface PurchaseKitchenListItem {
+    item: string;
+    quantity?: number;
+    unit?: string;
+    note?: string;
+}
+interface PurchaseBuyerKitchenContext {
+    object: 'buyer_kitchen_context';
+    buyerId: string;
+    /** Null when nothing was pushed. */
+    context: PurchaseKitchenContext | null;
+    summary: {
+        capturedAt: string;
+        inventory: number;
+        low: number;
+        out: number;
+        usuals: number;
+        recipes: number;
+        list: number;
+    } | null;
+    /** When Conto received the snapshot. */
+    receivedAt: string | null;
+}
+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;
+        /** Company card only. */
+        monthlyMinor?: number;
+        /** Company card only: orders above this wait for your review. */
+        reviewAboveMinor?: number;
+        currency: 'USD';
+    };
+    /** false for a company card delegation, which you review above `reviewAboveMinor` only. */
+    requiresPurchaseReview: boolean;
+    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;
+}
+/** Buyer-approved spending at one store; not a merchant-independent allowance. */
+interface PurchaseAllowance {
+    id: string;
+    object: 'allowance';
+    buyerId: string;
+    agentId: string;
+    delegationId: string;
+    paymentMethodId: string;
+    environment: 'live' | 'test';
+    status: 'pending_verification' | 'active' | 'revoked' | 'expired';
+    kind: 'store' | 'recurrence';
+    merchant: {
+        name: string;
+        origin: string;
+    };
+    limits: {
+        perPurchaseMinor: number;
+        periodMinor: number;
+        period: 'day' | 'week' | 'month';
+        totalMinor: number;
+        currency: 'USD';
+    };
+    expiresAt: string;
+    createdAt: string;
+    activatedAt: string | null;
+    revokedAt: string | null;
+}
+interface PurchasingSettings {
+    /** Origins a hosted page may return the buyer to. */
+    allowedReturnOrigins: string[];
+    /** Whether Conto emails buyers about their purchases. On by default. */
+    buyerEmails: boolean;
+}
+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[];
+    /** Checkout paths: `browser_checkout`, `store_order` and `test_store`. */
+    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;
+    }>;
+    /** Whether your app can push what its buyers have at home. */
+    kitchenContext?: {
+        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;
+    /** Inspect or revoke buyer-approved allowances. Grants remain on the buyer's hosted page. */
+    readonly allowances: {
+        /** Returns up to 50 allowances for this buyer, newest first. */
+        list: (params: {
+            buyerId: string;
+        }) => Promise<{
+            items: PurchaseAllowance[];
+        }>;
+        get: (id: string) => Promise<PurchaseAllowance>;
+        /** Stops future credential release; does not undo payments already submitted. */
+        revoke: (id: string) => Promise<PurchaseAllowance>;
+    };
+    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>;
+        /**
+         * Lets the buyer pay with your company card within limits you set for
+         * them, or replaces those limits. The buyer must not have their own card.
+         */
+        setCompanyCard: (id: string, input: {
+            companyCardId: string;
+            limits: PurchaseBuyerCompanyCardLimits;
+        }) => Promise<PurchaseBuyerCompanyCard>;
+        /** The buyer stops paying with your company card. */
+        removeCompanyCard: (id: string) => Promise<{
+            buyerId: string;
+            object: "buyer_company_card";
+            removed: true;
+        }>;
+        /**
+         * Replaces what the buyer has at home: inventory, usuals, preferences,
+         * chosen recipes and their list. The whole snapshot, every time. Needs
+         * Conto to enable kitchen context for your organization.
+         */
+        setKitchenContext: (id: string, context: PurchaseKitchenContext) => Promise<PurchaseBuyerKitchenContext>;
+        /** The snapshot Conto holds, with context null when nothing was pushed. */
+        getKitchenContext: (id: string) => Promise<PurchaseBuyerKitchenContext>;
+        clearKitchenContext: (id: string) => Promise<{
+            buyerId: string;
+            object: "buyer_kitchen_context";
+            removed: true;
+        }>;
+    };
+    /** Cards your organization pays its buyers' purchases with. Test cards only for now. */
+    readonly companyCards: {
+        create: (input: {
+            environment: "live" | "test";
+            limits: {
+                perPurchaseMinor: number;
+                monthlyMinor: number;
+            };
+        }) => Promise<PurchaseCompanyCard>;
+        list: () => Promise<{
+            items: PurchaseCompanyCard[];
+        }>;
+        get: (id: string) => Promise<PurchaseCompanyCard>;
+        /** Changes the card's own caps. Each buyer's limits stay as they are. */
+        update: (id: string, input: {
+            limits: {
+                perPurchaseMinor: number;
+                monthlyMinor: number;
+            };
+        }) => Promise<PurchaseCompanyCard>;
+        /** No buyer can start or pay a purchase with the card after this. */
+        remove: (id: string) => Promise<PurchaseCompanyCard>;
+    };
+    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<PurchasingSettings>;
+        /** Changes only the fields you pass. */
+        update: (input: {
+            allowedReturnOrigins?: string[];
+            buyerEmails?: boolean;
+        }) => Promise<PurchasingSettings>;
+    };
+    /** 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;
@@ -647,9 +1429,25 @@ declare class ContoAdmin {
     cards: AdminCardsClient;
     policies: PoliciesClient;
     team: TeamClient;
+    /** 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>;
+    /**
+     * 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.
+     */
+    request<T>(method: string, path: string, body?: Record<string, unknown>, options?: {
+        idempotent?: boolean;
+    }): Promise<T>;
 }
 declare class AdminCardsClient {
     private client;
@@ -1179,7 +1977,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 */
@@ -1479,6 +2277,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 +2481,34 @@ interface BeginCheckoutCheckpointInput {
     /** Defaults to one Total entry equal to amountMinor. */
     totals?: CommerceTotalInput[];
 }
+/**
+ * The payment behind a checkout, such as the Link spend request that issued a
+ * Link card. An id only, never card data.
+ */
+interface CheckoutPaymentReference {
+    provider: 'LINK';
+    /** The Link spend request id, such as lsrq_... */
+    id: string;
+}
 /** Second checkpoint: the final total shown right before the payment is submitted. */
 interface ConfirmCheckoutCheckpointInput {
     amountMinor: number;
     currency?: 'USD';
-    /** Final line items, needed only when the total changed. Defaults to the approved items. */
+    /** Observed final items. Supplied items are checked even when the total is unchanged. */
     lineItems?: CommerceLineItemInput[];
-    /** Final totals, such as tax and shipping. Defaults to one Total entry. */
+    /** Observed final charges. Supplied charges are checked even when the total is unchanged. */
     totals?: CommerceTotalInput[];
     /** Page where the payment is submitted: the merchant's site or the payment method's. */
     pageUrl?: string;
+    /** The Link card's spend request, from getLinkCard(). */
+    paymentReference?: CheckoutPaymentReference;
 }
 interface ReportCheckoutOutcomeInput {
     outcome: CheckoutOutcome;
     /** Merchant order or receipt number. Never a payment credential. */
     reference?: string;
+    /** The Link card's spend request, from getLinkCard(). */
+    paymentReference?: CheckoutPaymentReference;
 }
 interface CheckoutCheckpoint {
     id: string;
@@ -1707,6 +2535,8 @@ interface CheckoutCheckpoint {
     /** Present when the agent's rules sent this purchase to the owner for approval. */
     approval?: CheckoutCheckpointApproval;
     outcomeReference?: string;
+    /** The payment your checkout reported at confirm or outcome, such as a Link spend request. */
+    paymentReference?: CheckoutPaymentReference;
     /** Outcomes are reported by your checkout. Conto does not verify settlement here. */
     settlementVerified: false;
 }
@@ -1723,6 +2553,45 @@ interface WaitForCheckoutApprovalOptions {
     pollIntervalMs?: number;
     signal?: AbortSignal;
 }
+
+/**
+ * A Link card for one purchase: the checkpoint begin input plus the Link
+ * wallet that runs in your environment. The checkout method is always LINK.
+ */
+interface GetLinkCardInput extends Omit<BeginCheckoutCheckpointInput, 'checkoutMethod'> {
+    /** For example linkCliWallet() from @conto_finance/sdk/link-wallet. */
+    wallet: LinkWallet;
+    /** How long to wait for the owner when a rule requires approval. Defaults to 10 minutes. */
+    ownerApprovalTimeoutMs?: number;
+    /** How long to wait for the person to approve in Link. Defaults to 10 minutes. */
+    linkApprovalTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+/** A new Link card for a changed final total. */
+interface ReplaceLinkCardInput {
+    wallet: LinkWallet;
+    /** The final total in cents, including shipping and tax. */
+    amountMinor: number;
+    /** Final line items. Defaults to the approved items. */
+    lineItems?: CommerceLineItemInput[];
+    /** Final totals, such as tax and shipping. Defaults to one Total entry. */
+    totals?: CommerceTotalInput[];
+    ownerApprovalTimeoutMs?: number;
+    linkApprovalTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface LinkCardResult {
+    /** The approved checkpoint. Pass it to confirm() right before paying. */
+    checkpoint: CheckoutCheckpoint;
+    /**
+     * Live card data for this purchase only. It stays in this process: printing
+     * or serializing the result shows only the last four digits.
+     */
+    card: LinkCardCredential;
+    linkRequestId: string;
+    /** Pass to confirm() and reportOutcome() so the owner sees which Link request paid. */
+    paymentReference: CheckoutPaymentReference;
+}
 /** 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. */
@@ -2414,6 +3283,41 @@ declare class CheckoutApprovalTimeoutError extends ContoError {
     readonly checkpoint: CheckoutCheckpoint;
     constructor(checkpoint: CheckoutCheckpoint);
 }
+/**
+ * getLinkCard() or replaceLinkCard() stopped after Conto approved the purchase.
+ * No card was returned. Conto cancelled the checkpoint to release the held
+ * spend unless holdReleased is false. Do not pay.
+ */
+declare class LinkCardError extends ContoError {
+    readonly checkpoint: CheckoutCheckpoint;
+    readonly linkRequestId?: string;
+    /** True when Conto cancelled the checkpoint and released the held spend. */
+    readonly holdReleased: boolean;
+    constructor(input: {
+        message: string;
+        code: string;
+        checkpoint: CheckoutCheckpoint;
+        linkRequestId?: string;
+        holdReleased: boolean;
+        retryGuidance?: string;
+    });
+}
+/** The person declined the Link card request, or it was cancelled in Link. */
+declare class LinkCardDeniedError extends LinkCardError {
+    constructor(input: ConstructorParameters<typeof LinkCardError>[0]);
+}
+/** The Link card request expired before the person approved it. */
+declare class LinkCardExpiredError extends LinkCardError {
+    constructor(input: ConstructorParameters<typeof LinkCardError>[0]);
+}
+/** The person did not approve in Link before linkApprovalTimeoutMs. Conto cancelled the request. */
+declare class LinkCardTimeoutError extends LinkCardError {
+    constructor(input: ConstructorParameters<typeof LinkCardError>[0]);
+}
+/** The Link wallet cannot run here: link-cli is not installed or not logged in. */
+declare class LinkWalletUnavailableError extends LinkCardError {
+    constructor(input: ConstructorParameters<typeof LinkCardError>[0]);
+}
 interface ContoRequestOptions {
     /** Set only when repeating this request cannot create an additional side effect. */
     idempotent?: boolean;
@@ -2432,6 +3336,10 @@ 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);
     /**
      * Normalize and durably revise a partial agent purchase proposal without
@@ -2510,6 +3418,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>;
 }
@@ -2597,17 +3514,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>;
 }
 /**
@@ -2823,6 +3757,37 @@ declare class CheckoutClient {
      */
     cancel(checkpointId: string): Promise<CheckoutCheckpoint>;
     get(checkpointId: string): Promise<CheckoutCheckpoint>;
+    /**
+     * Get a Stripe Link card for one purchase, issued only after Conto approves
+     * it. Call this at the payment step, once the final total with shipping and
+     * tax is known.
+     *
+     * 1. Conto runs checkpoint 1 and holds the spend. When a rule requires the
+     *    owner's approval, this waits for it.
+     * 2. Only then does the wallet ask Link for a card for exactly the approved
+     *    amount at this merchant. The person approves it in their Link app.
+     * 3. The card is returned. It never reaches Conto.
+     *
+     * Then fill in the card, call confirm(result.checkpoint, { amountMinor,
+     * paymentReference: result.paymentReference }) right before paying, pay only
+     * if it resolves, and report the outcome. If the final total differs, call
+     * replaceLinkCard() instead of confirming.
+     *
+     * A Conto denial throws before Link is called. When Link declines, expires,
+     * times out, or is unavailable, this cancels the checkpoint to release the
+     * held spend and throws a LinkCardError. When Conto cannot cancel an open Link
+     * request, it keeps the hold and throws LINK_CARD_NOT_CANCELLED with the
+     * request id. Retrying with the same input resumes the same checkpoint and
+     * Link request.
+     */
+    getLinkCard(input: GetLinkCardInput): Promise<LinkCardResult>;
+    /**
+     * The final total differs from the one the Link card covers. This cancels
+     * the old Link request and checkpoint, begins a checkpoint at the final
+     * total (waiting for the owner when a rule requires it), and gets a new card
+     * for it. Confirm the returned checkpoint with the same total.
+     */
+    replaceLinkCard(previous: LinkCardResult, input: ReplaceLinkCardInput): Promise<LinkCardResult>;
 }
 
-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, 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 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, 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, 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 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 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 CheckoutPaymentReference, 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, type GetLinkCardInput, Conto as Giro, type ContoConfig as GiroConfig, ContoError as GiroError, type GuardCheckoutResult, type GuardedBrowserDispatchResult, type GuardedCheckoutInput, LinkCardCredential, LinkCardDeniedError, LinkCardError, LinkCardExpiredError, type LinkCardResult, LinkCardTimeoutError, LinkWallet, type LinkWalletInput, LinkWalletUnavailableError, 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 PurchaseAllowance, type PurchaseBuyer, type PurchaseBuyerCompanyCard, type PurchaseBuyerCompanyCardLimits, type PurchaseBuyerKitchenContext, type PurchaseCompanyCard, type PurchaseDelegation, type PurchaseEvent, type PurchaseEventPage, type PurchaseEvidence, type PurchaseGroceryItem, type PurchaseGroceryList, type PurchaseHostedLink, type PurchaseItem, type PurchaseKitchenContext, type PurchaseKitchenInventoryItem, type PurchaseKitchenListItem, type PurchaseKitchenPreferences, type PurchaseKitchenRecipe, type PurchaseKitchenUsual, type PurchaseList, type PurchaseMoney, type PurchasePaymentMethod, type PurchasePhase, type PurchaseRequest, type PurchaseResponseAck, type PurchaseStatus, PurchasesClient, type PurchasingCapabilities, type PurchasingSettings, type RecurringPurchase, type RecurringPurchaseCycleResult, type RecurringPurchaseCycleStatus, RecurringPurchasesClient, type RefreshBalanceResult, type RegisterExternalCardInput, type ReplaceLinkCardInput, 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 };