commerceforai 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,761 @@
+import type { Collection, CollectionParams, Customer, CustomerDetail, Discount, DiscountParams, SalesReport, Checkout, CheckoutCreateParams, Dimensions, Email, Event, EventType, Label, List, Order, OrderStatus, Parcel, Product, ProductCreateParams, ProductUpdateParams, Result, Return, ShipFromAddress, ShippingRate, Store, StorefrontConfig, Variant, VariantInput, VariantUpdateParams, WebhookEndpoint } from "./types.js";
+export type * from "./types.js";
+export interface CommerceOptions {
+    /** Defaults to COMMERCEFORAI_BASE_URL, then https://api.commerceforai.com. */
+    baseUrl?: string;
+    /** Retries for network errors, 429 and 5xx. POSTs are retried with the same Idempotency-Key. Default 2. */
+    maxRetries?: number;
+    /** Custom fetch (e.g. for testing or proxies). */
+    fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+}
+type Query = Record<string, string | number | boolean | undefined>;
+/**
+ * ```ts
+ * const commerce = new Commerce(process.env.COMMERCEFORAI_API_KEY);
+ * const { data, error } = await commerce.checkouts.create({ items: [{ variant_id, quantity: 1 }], success_url });
+ * ```
+ */
+export declare class Commerce {
+    readonly products: Products;
+    readonly variants: Variants;
+    readonly inventory: InventoryResource;
+    readonly checkouts: Checkouts;
+    readonly orders: Orders;
+    readonly events: Events;
+    readonly webhooks: Webhooks;
+    readonly store: StoreResource;
+    readonly returns: Returns;
+    readonly emails: Emails;
+    readonly collections: Collections;
+    readonly customers: Customers;
+    readonly discounts: Discounts;
+    readonly reports: Reports;
+    readonly printify: PrintifyResource;
+    readonly files: Files;
+    private readonly key;
+    private readonly baseUrl;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    constructor(apiKey?: string, opts?: CommerceOptions);
+    /** @internal */
+    request<T>(method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE", path: string, opts?: {
+        body?: unknown;
+        query?: Query;
+        idempotencyKey?: string;
+    }): Promise<Result<T>>;
+}
+declare abstract class Resource {
+    protected readonly client: Commerce;
+    constructor(client: Commerce);
+}
+declare class Products extends Resource {
+    /**
+     * Create up to 100 products in one request. Each succeeds or fails on its own; retry only the failures.
+     * Returns { created, failed, results: [{ index, product } | { index, error }] }.
+     */
+    createMany(products: ProductCreateParams[]): Promise<Result<{
+        object: "bulk_result";
+        created: number;
+        failed: number;
+        results: ({
+            index: number;
+            product: Product;
+        } | {
+            index: number;
+            error: {
+                type: string;
+                message: string;
+                param?: string;
+            };
+        })[];
+    }>>;
+    /** Create a product. Use `price` for a single-variant product, or `variants` for sizes/colors. */
+    create(params: ProductCreateParams, opts?: {
+        idempotencyKey?: string;
+    }): Promise<Result<Product>>;
+    get(id: string): Promise<Result<Product>>;
+    /** `metadata` filters on exact matches, e.g. { collection: "yosemite" }. */
+    /** `q` searches product names and SKUs. */
+    list(params?: {
+        limit?: number;
+        starting_after?: string;
+        active?: boolean;
+        q?: string;
+        metadata?: Record<string, string>; /** Collection id or handle. */
+        collection?: string;
+    }): Promise<Result<List<Product>>>;
+    update(id: string, params: ProductUpdateParams): Promise<Result<Product>>;
+    /** Archive: hides it from sale; existing orders are unaffected. */
+    archive(id: string): Promise<Result<Product>>;
+    addVariant(productId: string, params: VariantInput): Promise<Result<Variant>>;
+}
+declare class Variants extends Resource {
+    update(id: string, params: VariantUpdateParams): Promise<Result<Variant>>;
+}
+declare class InventoryResource extends Resource {
+    /** Tracked variants, lowest stock first. */
+    list(params?: {
+        low_stock_threshold?: number;
+    }): Promise<Result<List<Variant & {
+        product_name: string;
+    }>>>;
+    /** Add/remove units, e.g. `{ adjust: 50 }` after a restock or `{ adjust: -1 }` for damage. */
+    adjust(variantId: string, adjust: number, reason?: string): Promise<Result<Variant>>;
+    /** Set the absolute on-hand count, e.g. after a stock count. */
+    set(variantId: string, onHand: number, reason?: string): Promise<Result<Variant>>;
+}
+declare class Checkouts extends Resource {
+    /** Reserve stock and create a Stripe-hosted checkout. Redirect the customer to `data.url`. */
+    create(params: CheckoutCreateParams, opts?: {
+        idempotencyKey?: string;
+    }): Promise<Result<Checkout>>;
+    get(id: string): Promise<Result<Checkout>>;
+}
+declare class Orders extends Resource {
+    /** `q` matches an order number, customer email or name. */
+    list(params?: {
+        limit?: number;
+        starting_after?: string;
+        status?: OrderStatus | OrderStatus[];
+        q?: string;
+    }): Promise<Result<List<Order>>>;
+    /** Accepts an order id (`ord_...`) or order number (`1001`). */
+    get(idOrNumber: string | number): Promise<Result<Order>>;
+    update(id: string | number, params: {
+        note?: string | null;
+        metadata?: Record<string, string>;
+    }): Promise<Result<Order>>;
+    /** Mark shipped. Calling again updates tracking. */
+    fulfill(id: string | number, params?: {
+        carrier?: string;
+        tracking_number?: string;
+        tracking_url?: string;
+    }): Promise<Result<Order>>;
+    /**
+     * Get live label rates from your EasyPost/Shippo account, cheapest first.
+     * Parcel weight defaults to the sum of variant `weight_oz`. Pass `return_id` for return-label rates.
+     */
+    shippingRates(id: string | number, params?: {
+        parcel?: Parcel;
+        return_id?: string;
+    }): Promise<Result<List<ShippingRate> & {
+        parcel: Required<Parcel>;
+    }>>;
+    /** Buy a label for a rate. Outbound labels also mark the order fulfilled with tracking (and email the customer). */
+    buyLabel(id: string | number, rateId: string, opts?: {
+        max_cost?: number;
+    }): Promise<Result<Label>>;
+    /** Send a paid order to the print-on-demand provider now (e.g. after fixing a missing print file). */
+    submitFulfillment(id: string | number, params?: {
+        provider?: "printful" | "printify";
+    }): Promise<Result<Order>>;
+    labels(id: string | number): Promise<Result<List<Label>>>;
+    /** Refund through Stripe. Omit `amount` for a full refund; `restock` returns items to inventory. */
+    refund(id: string | number, params?: {
+        amount?: number;
+        restock?: boolean;
+        reason?: "duplicate" | "fraudulent" | "requested_by_customer";
+    }): Promise<Result<Order>>;
+}
+declare class Collections extends Resource {
+    /** Group products, e.g. { name: "Mugs", product_ids: [...] }. The handle defaults from the name. */
+    create(params: CollectionParams & {
+        name: string;
+    }): Promise<Result<Collection>>;
+    list(): Promise<Result<List<Collection>>>;
+    /** By id or handle. */
+    get(idOrHandle: string): Promise<Result<Collection>>;
+    /** Passing product_ids replaces the membership (in that order). */
+    update(idOrHandle: string, params: CollectionParams): Promise<Result<Collection>>;
+    addProducts(idOrHandle: string, productIds: string[]): Promise<Result<Collection>>;
+    removeProduct(idOrHandle: string, productId: string): Promise<Result<Collection>>;
+    delete(idOrHandle: string): Promise<Result<{
+        id: string;
+        deleted: true;
+    }>>;
+}
+declare class Customers extends Resource {
+    /** Everyone who has paid, matched by email. Search by email or name; sort by recent (default), spent or orders. */
+    list(params?: {
+        q?: string;
+        sort?: "recent" | "spent" | "orders";
+        limit?: number;
+        page?: number;
+    }): Promise<Result<List<Customer> & {
+        page: number;
+    }>>;
+    /** Totals, last address and full order history for one email. */
+    get(email: string): Promise<Result<CustomerDetail>>;
+}
+declare class Discounts extends Resource {
+    /** e.g. { code: "SUMMER20", kind: "percent", value: 20 } or { code: "FIVEOFF", kind: "amount", value: 500 }. */
+    create(params: DiscountParams): Promise<Result<Discount>>;
+    list(): Promise<Result<List<Discount>>>;
+    /** By id or code. */
+    get(idOrCode: string): Promise<Result<Discount>>;
+    update(idOrCode: string, params: Partial<DiscountParams>): Promise<Result<Discount>>;
+    delete(idOrCode: string): Promise<Result<{
+        id: string;
+        deleted: true;
+    }>>;
+}
+declare class Reports extends Resource {
+    /** Sales over the last `days` (default 30, max 366): totals vs the previous period, a time series and top products. */
+    sales(params?: {
+        days?: number;
+    }): Promise<Result<SalesReport>>;
+}
+/**
+ * Printify, through the shop the store connected (your agent never needs the Printify token).
+ * Find a blueprint → a print provider → its variants, then create the product in Printify.
+ */
+declare class PrintifyResource extends Resource {
+    /** Search Printify's catalog, e.g. blueprints({ q: "heavy cotton tee" }). */
+    blueprints(params?: {
+        q?: string;
+        limit?: number;
+    }): Promise<Result<{
+        object: "list";
+        data: {
+            id: number;
+            title: string;
+            brand: string;
+            model: string;
+            images: string[];
+        }[];
+        total: number;
+    }>>;
+    providers(blueprintId: number): Promise<Result<{
+        object: "list";
+        data: {
+            id: number;
+            title: string;
+            location: unknown;
+        }[];
+    }>>;
+    /** Variant ids per size/color, the option values, and the print placements ("front", "back"…). */
+    variants(blueprintId: number, providerId: number): Promise<Result<{
+        object: "printify_variants";
+        options: Record<string, string[]>;
+        data: {
+            id: number;
+            title: string;
+            options: Record<string, string>;
+            placements: {
+                position: string;
+                width: number;
+                height: number;
+            }[];
+        }[];
+    }>>;
+    /**
+     * Create a CommerceForAI product in your Printify shop (artwork uploaded, variants priced, mockups made) and map
+     * its variants so paid orders go to production. Variants are matched by option values; pass fixed_options for
+     * options yours don't have (e.g. { color: "Black" }), or variant_map to map explicitly.
+     */
+    createProduct(productId: string, params: {
+        blueprint_id: number;
+        print_provider_id: number;
+        print_files?: {
+            placement: string;
+            url: string;
+        }[];
+        fixed_options?: Record<string, string>;
+        variant_map?: Record<string, number>;
+        use_mockups?: boolean;
+    }): Promise<Result<{
+        object: "printify_product";
+        printify_product_id: string;
+        mockups: string[];
+        product: Product;
+    }>>;
+}
+export interface HostedFile {
+    object: "file";
+    id: string;
+    /** Permanent public URL on cdn.commerceforai.com. */
+    url: string;
+    filename: string | null;
+    content_type: "image/png" | "image/jpeg" | "image/webp";
+    bytes: number;
+    width: number | null;
+    height: number | null;
+    source_url: string | null;
+    created_at: string;
+}
+/**
+ * Image hosting (product photos, logos, print files): PNG, JPEG or WebP up to 25 MB, 5 GB per store.
+ * Photo metadata is removed; the same image is stored once; URLs never change.
+ */
+declare class Files extends Resource {
+    /**
+     * Upload bytes (Blob, File, Buffer, Uint8Array) or copy from a link.
+     * ```ts
+     * await commerce.files.upload(readFileSync("art/half-dome.png"), { filename: "half-dome.png" });
+     * await commerce.files.upload({ url: "https://example.com/photo.jpg" });
+     * ```
+     */
+    upload(input: Blob | ArrayBuffer | Uint8Array | {
+        url: string;
+    }, opts?: {
+        filename?: string;
+    }): Promise<Result<HostedFile>>;
+    list(params?: {
+        limit?: number;
+        starting_after?: string;
+    }): Promise<Result<List<HostedFile> & {
+        usage: {
+            bytes: number;
+            files: number;
+            quota_bytes: number;
+        };
+    }>>;
+    delete(id: string): Promise<Result<{
+        id: string;
+        deleted: true;
+    }>>;
+    /**
+     * Copy products' outside images (and print files) onto the CDN so a moved or deleted source can't break the store.
+     */
+    copyProductImages(productId: string): Promise<Result<{
+        product_id: string;
+        copied: number;
+        errors: {
+            url: string;
+            message: string;
+        }[];
+    }>>;
+    /** The same for every product with outside images, up to `limit` (≤50) per call. Repeat until `remaining` is 0. */
+    copyAllProductImages(opts?: {
+        limit?: number;
+    }): Promise<Result<{
+        processed: number;
+        copied: number;
+        remaining: number;
+        errors: {
+            product_id: string;
+            url: string;
+            message: string;
+        }[];
+    }>>;
+}
+declare class Returns extends Resource {
+    /** Open a return for items on a shipped order. */
+    create(orderId: string | number, params: {
+        items: {
+            variant_id: string;
+            quantity: number;
+        }[];
+        reason?: string;
+    }): Promise<Result<Return>>;
+    list(params?: {
+        status?: Return["status"];
+        order_id?: string | number;
+        limit?: number;
+    }): Promise<Result<List<Return>>>;
+    get(id: string): Promise<Result<Return>>;
+    /** Approve. `return_label: "cheapest"` buys a prepaid return label and includes it in the customer email. */
+    approve(id: string, params?: {
+        return_label?: "cheapest" | {
+            rate_id: string;
+        };
+        note?: string;
+    }): Promise<Result<Return>>;
+    reject(id: string, params?: {
+        note?: string;
+    }): Promise<Result<Return>>;
+    /** Items arrived: restock (default true) and refund their value (default true; shipping not included). */
+    receive(id: string, params?: {
+        restock?: boolean;
+        refund?: boolean;
+        refund_amount?: number;
+    }): Promise<Result<Return>>;
+}
+declare class Emails extends Resource {
+    /** Log of customer emails sent (or queued) for your store. */
+    list(params?: {
+        order_id?: string | number;
+    }): Promise<Result<List<Email>>>;
+    /** Render a customer email with your branding and sample data. Templates: order_confirmation, order_shipped, order_refunded, return_approved, checkout_recovery. */
+    preview(template: EmailTemplate): Promise<Result<{
+        template: EmailTemplate;
+        subject: string;
+        html: string;
+        text: string;
+    }>>;
+    /** Send previews to the store owner (or the signed-in member): one template, or "all". */
+    sendTest(params?: {
+        template?: EmailTemplate | "all";
+    }): Promise<Result<{
+        sent: number;
+        to: string;
+        templates: EmailTemplate[];
+    }>>;
+}
+export interface StoreSyncPlan {
+    object: "sync_plan";
+    plan_id: string;
+    has_changes: boolean;
+    direction: "test_to_live" | "live_to_test";
+    source: {
+        id: string;
+        name: string;
+        mode: string;
+    };
+    destination: {
+        id: string;
+        name: string;
+        mode: string;
+    };
+    products: {
+        create: {
+            source_id: string;
+            name: string;
+            variants: number;
+        }[];
+        update: {
+            id: string;
+            name: string;
+            fields: string[];
+            new_variants: number;
+            updated_variants: number;
+            prices: {
+                variant: string;
+                from: number;
+                to: number;
+            }[];
+        }[];
+        unchanged: number;
+        only_in_destination: {
+            id: string;
+            name: string;
+        }[];
+    };
+    collections: {
+        create: string[];
+        update: string[];
+    };
+    discounts: {
+        create: string[];
+        update: string[];
+    };
+    settings: string[];
+}
+export type EmailTemplate = "order_confirmation" | "order_shipped" | "order_refunded" | "return_approved" | "checkout_recovery";
+declare class Events extends Resource {
+    /** Poll events in order. Pass the last id you processed as `after`. `type` accepts wildcards like `order.*`. */
+    list(params?: {
+        after?: string;
+        type?: EventType | `${string}.*`;
+        limit?: number;
+    }): Promise<Result<List<Event<unknown>>>>;
+}
+export interface ChatgptChannel {
+    object: "chatgpt_channel";
+    status: "not_applied" | "applied" | "approved" | "not_approved";
+    applied_at: string | null;
+    decided_at: string | null;
+    ready_to_apply: boolean;
+    steps: {
+        key: string;
+        status: "done" | "todo" | "warning";
+        message: string;
+        fix?: string;
+    }[];
+    feed: Pick<FeedCheck, "items" | "items_ok" | "errors" | "warnings" | "formats">;
+    application: {
+        url: string;
+        answers: Record<string, string | boolean | null>;
+        you_provide: string[];
+    };
+    categories: string[];
+    next: string;
+}
+export interface FeedCheck {
+    object: "feed_check";
+    target: "openai";
+    items: number;
+    items_ok: number;
+    ready: boolean;
+    errors: {
+        item_id: string | null;
+        field: string;
+        message: string;
+    }[];
+    warnings: {
+        item_id: string | null;
+        field: string;
+        message: string;
+    }[];
+    formats: {
+        json: string;
+        jsonl_gz: string;
+    };
+    delivery: string;
+}
+export interface SetupItem {
+    key: string;
+    status: "done" | "todo" | "warning" | "optional";
+    message: string;
+    fix?: string;
+}
+export interface SetupStatus {
+    object: "setup_status";
+    store_id: string;
+    mode: "test" | "live";
+    ready_for_real_orders: boolean;
+    ready_for_test_orders: boolean;
+    next_step: SetupItem | null;
+    items: SetupItem[];
+    tip?: string;
+}
+export interface SimulatedOrder {
+    object: "simulated_order";
+    order: Order;
+    checkout_id: string;
+    events: string[];
+    webhooks: {
+        url: string;
+        deliveries: number;
+    }[];
+    emails_that_would_send: {
+        event: string;
+        to: string | null;
+        subject: string;
+    }[];
+    notes: string[];
+}
+export interface CatalogImport {
+    status: "running" | "succeeded" | "failed";
+    started_at: string;
+    finished_at?: string;
+    products_created: number;
+    products_updated: number;
+    variants_created: number;
+    variants_updated: number;
+    error?: string;
+}
+export interface GoLiveLink {
+    object: "go_live_link";
+    url: string;
+    expires_at: string;
+    steps: string[];
+}
+declare class StoreResource extends Resource {
+    get(): Promise<Result<Store>>;
+    /**
+     * Note on `tax_enabled`: Stripe only collects tax in jurisdictions where you have an active
+     * tax registration in Stripe Tax. Turning this on without registrations collects $0 tax.
+     */
+    /**
+     * Preview a sync from this store's other version (test or live) into this store. Nothing changes.
+     * Syncs cover products, prices, images, collections, discounts and shipping/email settings; never orders, keys, Stripe, site URLs or stock counts.
+     */
+    syncPreview(): Promise<Result<StoreSyncPlan>>;
+    /** Apply a sync into this store. Into a live store, pass the `plan_id` from syncPreview(). */
+    sync(params?: {
+        plan_id?: string;
+    }): Promise<Result<{
+        object: "sync_result";
+        products_created: number;
+        products_updated: number;
+        collections: number;
+        discounts: number;
+        settings: string[];
+        discount_errors: {
+            code: string;
+            message: string;
+        }[];
+    }>>;
+    update(params: {
+        name?: string;
+        tax_enabled?: boolean;
+        default_success_url?: string | null;
+        default_cancel_url?: string | null;
+        builtin_emails?: boolean;
+        recovery_emails?: boolean;
+        hosted_pages?: boolean;
+        /** Customer email branding. Logo is an https image URL; accent is a hex color like "#2f6f4e". */
+        email_brand?: {
+            logo_url?: string | null;
+            accent_color?: string | null;
+            address?: string | null;
+        };
+        /** Emails to your team: each new order, and when a variant's stock falls to the threshold (null turns it off). */
+        owner_alerts?: {
+            new_order?: boolean;
+            low_stock_threshold?: number | null;
+        };
+    }): Promise<Result<Store>>;
+    /**
+     * Would OpenAI's ChatGPT shopping accept this store's product feed? Per-item errors (rejected) and
+     * warnings (weaker listings), plus where the feed lives (JSON and the jsonl.gz upload format).
+     */
+    checkFeed(): Promise<Result<FeedCheck>>;
+    /** Sell in ChatGPT: readiness steps, suggested answers for OpenAI's merchant application, and status. */
+    chatgpt(): Promise<Result<ChatgptChannel>>;
+    /** Record the application's progress (after the owner submits it) or the product category to apply with. */
+    updateChatgpt(params: {
+        status?: ChatgptChannel["status"];
+        category?: string | null;
+        note?: string;
+    }): Promise<Result<ChatgptChannel>>;
+    /** Everything between this store and real orders, each with the exact fix. Start here when setting up. */
+    setupStatus(): Promise<Result<SetupStatus>>;
+    /**
+     * Test stores only: run a purchase end to end without a browser. Stock is reserved and committed, the
+     * order is created and paid, events and your webhooks fire; `fulfill: true` also marks it shipped.
+     * Never charges a card, reaches Printify/Printful, emails anyone, or counts toward usage.
+     */
+    simulateOrder(params: {
+        items: {
+            variant_id: string;
+            quantity: number;
+            properties?: Record<string, string>;
+        }[];
+        customer_email?: string;
+        customer_name?: string;
+        shipping_address?: {
+            line1: string;
+            line2?: string;
+            city: string;
+            state?: string;
+            postal_code: string;
+            country: string;
+        };
+        discount_code?: string;
+        shipping_rate?: {
+            name: string;
+            amount: number;
+        };
+        fulfill?: boolean;
+        metadata?: Record<string, string>;
+    }): Promise<Result<SimulatedOrder>>;
+    /**
+     * A one-time link (valid 7 days) to hand to a person when the store is ready for real orders. Opening it
+     * signs them in, claims the store if it's an unclaimed sandbox, creates a live copy (products, prices,
+     * inventory, settings and connections), and takes them to Connect Stripe. Test stores only.
+     */
+    goLiveLink(): Promise<Result<GoLiveLink>>;
+    /**
+     * Shipping every checkout offers unless it passes its own rates: up to 5 flat rates (cents), the
+     * countries you ship to, and an optional free-shipping threshold on the item subtotal (cents).
+     */
+    configureCheckoutShipping(params: {
+        countries: string[];
+        rates: {
+            name: string;
+            amount: number;
+            min_days?: number;
+            max_days?: number;
+        }[];
+        free_over?: number | null;
+    }): Promise<Result<Store>>;
+    /** Connect your EasyPost or Shippo account for label purchasing. */
+    configureShipping(params: {
+        provider: "easypost" | "shippo";
+        api_key: string;
+        ship_from: ShipFromAddress;
+        default_parcel?: Dimensions;
+    }): Promise<Result<Store>>;
+    /**
+     * Connect Printful or Printify (call once per provider; both can be connected — each variant routes to the
+     * provider it's mapped to). Paid orders with mapped variants are sent automatically — held for your
+     * approval in the provider's dashboard unless `auto_confirm: true`. Shipments mark orders fulfilled.
+     */
+    configureFulfillment(params: {
+        provider: "printful";
+        api_key: string;
+        printful_store_id?: string;
+        auto_confirm?: boolean;
+        import_catalog?: boolean;
+    } | {
+        provider: "printify";
+        api_key: string;
+        printify_shop_id: string;
+        auto_confirm?: boolean;
+        import_catalog?: boolean;
+    }): Promise<Result<Store & {
+        fulfillment_webhook: {
+            url: string | null;
+            registered: boolean;
+            error?: string;
+        };
+    }>>;
+    /**
+     * Import products from Shopify: pass Shopify's product export CSV (Products → Export) as `csv`, or
+     * `shop` (your-store.myshopify.com) + a custom app `access_token` (read_products, read_inventory).
+     * Safe to re-run: products match by Shopify id or SKU and existing prices and stock are kept.
+     */
+    importFromShopify(params: {
+        csv: string;
+    } | {
+        shop: string;
+        access_token: string;
+    }): Promise<Result<CatalogImport & {
+        object: "import";
+        source: "shopify";
+        products_seen: number;
+        warnings: string[];
+    }>>;
+    /**
+     * Import the products already set up in a connected Printify shop or Printful store (both when omitted).
+     * Runs in the background and happens automatically on connect; safe to re-run. Progress: `store.get()` → fulfillment[].catalog_import.
+     */
+    importCatalog(params?: {
+        provider?: "printful" | "printify";
+    }): Promise<Result<{
+        object: "list";
+        data: ({
+            provider: "printful" | "printify";
+        } & CatalogImport)[];
+    }>>;
+    /** Disconnect one provider, or all when omitted. */
+    disableFulfillment(provider?: "printful" | "printify"): Promise<Result<Store>>;
+    /** Send customer emails (confirmation, shipped, refunded, return approved) from your domain via Resend. */
+    configureEmails(params: {
+        resend_api_key: string;
+        from: string;
+        reply_to?: string;
+        events?: ("order.paid" | "order.fulfilled" | "order.refunded" | "return.approved")[];
+    }): Promise<Result<Store>>;
+    disableEmails(): Promise<Result<Store>>;
+    /**
+     * Publish product feeds for AI shopping surfaces (OpenAI/ACP JSON, Google Merchant XML) and,
+     * with `agent_access: true`, a public API third-party shopping agents can use to create checkout links.
+     */
+    configureStorefront(params: StorefrontConfig & {
+        agent_access?: boolean;
+    }): Promise<Result<Store>>;
+}
+declare class Webhooks extends Resource {
+    create(params: {
+        url: string;
+        events?: (EventType | "*" | `${string}.*`)[];
+    }): Promise<Result<WebhookEndpoint>>;
+    list(): Promise<Result<List<WebhookEndpoint>>>;
+    remove(id: string): Promise<Result<{
+        id: string;
+        deleted: true;
+    }>>;
+    /** Verify a webhook we sent you. Throws if the signature is invalid or too old. */
+    verify(args: {
+        payload: string;
+        headers: Headers | Record<string, string | undefined>;
+        secret: string;
+        toleranceSeconds?: number;
+    }): Promise<Event<unknown>>;
+}
+/**
+ * Verify a CommerceForAI webhook (Standard Webhooks format). Works in Node 18+, Bun, Deno and edge runtimes.
+ * Pass the raw request body string, not parsed JSON.
+ */
+export declare function verifyWebhook({ payload, headers, secret, toleranceSeconds, }: {
+    payload: string;
+    headers: Headers | Record<string, string | undefined>;
+    secret: string;
+    toleranceSeconds?: number;
+}): Promise<Event>;
+export default Commerce;
+export { createCheckoutHandler, type CheckoutHandlerOptions } from "./checkout-handler.js";
+export * from "./cart-core.js";