@sixtyninecommerce/client 0.30.0 → 0.31.0

package/dist/types.d.ts

@@ -1,4 +1,8 @@
-import type { ChannelResolver } from '@sixtyninecommerce/core';
+import type { ChannelResolver, ConditionalReadsOption, DeprecationNotice } from '@sixtyninecommerce/core';
+import type * as Cms from './generated/cms.js';
+import type * as Plugins from './generated/plugins.js';
+import type * as Shop from './generated/shop.js';
+import type { ProductMetadata } from './seo/metadata-types.js';
 /** Retry configuration for transient GET failures. */
 export interface RetryConfig {
     /** Maximum number of attempts including the first request. Default: 2. */
@@ -20,6 +24,12 @@ export interface RequestOptions {
      * requests only; see {@link StorefrontClientConfig.cacheTags}.
      */
     cacheTags?: readonly string[];
+    /**
+     * The shopper THIS call is for, overriding
+     * {@link StorefrontClientConfig.buyerIp}. Only sent by a client built with a
+     * `privateToken`; ignored otherwise.
+     */
+    buyerIp?: string;
 }
 /**
  * Decides the cache tags a commerce request carries. Receives the SDK's
@@ -37,8 +47,41 @@ export type CacheTagResolver = (tags: readonly string[], request: {
  * customer, because Vendure's fallback lookup is "the one active order for this
  * customer in this channel" — separate cookies do not change that. Setting a
  * scope keeps the two carts apart.
+ *
+ * The Shop API's own `OrderScope` enum: the values the engine stores on an
+ * order and reads from the `x-order-scope` header.
+ */
+export type OrderScope = Shop.OrderScope;
+/**
+ * A head KEY (Dashboard → Settings → Heads), sent as `x-head`. The platform
+ * composes every link it emails for the request — sign-in, magic link,
+ * invite, password reset — on that head's origin, so a trade portal's
+ * shoppers land back on the trade portal.
+ *
+ * Any key the store registered, in the server's own form (lowercase letters,
+ * digits and single hyphens, at most 64 characters); the three suggested are
+ * the conventional keys. The platform honours a key only when it names a head
+ * of kind `web`, `trade` or `native`, and ignores any other — including a key
+ * that names no head — by falling back to the store's default head.
+ */
+export type HeadKey = 'web' | 'trade' | 'native' | (string & {});
+/**
+ * Which storefront a magic-link email lands on: `'CONSUMER'` links to
+ * `/sign-in/magic`, `'B2B'` to `/b2b/login/magic`. Pass the entry point the
+ * shopper started from. It is not an authorization signal — B2B portal access
+ * is still checked when the link or code is consumed. The Shop API's own
+ * `MagicLinkPortal` enum.
  */
-export type OrderScope = 'CONSUMER' | 'TRADE';
+export type MagicLinkPortal = Shop.MagicLinkPortal;
+/** Options for {@link CommerceModule.requestMagicLink}. */
+export interface RequestMagicLinkOptions {
+    /**
+     * The storefront the emailed link should open. Omitted, the engine derives
+     * it from the account (a B2B customer gets the B2B path), which is what
+     * every release before this option did.
+     */
+    portal?: MagicLinkPortal;
+}
 /** Configuration for creating a storefront client. */
 export interface StorefrontClientConfig {
     storeCode: string;
@@ -47,7 +90,36 @@ export interface StorefrontClientConfig {
     cmsUrl?: string;
     pluginsUrl?: string;
     defaultLanguageCode?: string;
+    /**
+     * The currency the shopper chose, restored — e.g. from a cookie on a
+     * server-rendered request. Every Shop API request then names it
+     * (`?currencyCode=`), so catalogue prices, the cart and checkout are all in
+     * it, and `pricing.format*` default to it. Unset: the channel's default
+     * currency, and nothing is sent.
+     *
+     * A shopper chooses with `commerce.setOrderCurrency(code)`, which switches the
+     * client the same way; persist that code and pass it here on the next request.
+     *
+     * Three upper-case letters, or construction throws 400 `INVALID_ARGUMENT`. A
+     * currency the store does not offer (anymore) cannot be checked here — the
+     * client does not hold the channel's currency list — so the first Shop API
+     * request refuses it with `CURRENCY_NOT_AVAILABLE`, and the client goes back
+     * to the channel's default currency: drop the stored code. The engine-side
+     * limits of a non-default currency are listed on `commerce.setOrderCurrency`.
+     */
+    currencyCode?: string;
     fetch?: typeof globalThis.fetch;
+    /**
+     * Start the client SIGNED IN as a customer: the bearer is sent on every Vendure
+     * Shop API call, exactly as a token from `login` or `setAuthToken` would be.
+     * Never sent to the CMS or the plugins service.
+     *
+     * This is how a trusted-agent session is used: `admin.customers.actAs(customerId,
+     * { reason })` on `@sixtyninecommerce/admin` answers `{ token }`, and a server-side
+     * client built with `customerToken: token` acts inside that customer's cart and
+     * checkout for 15 minutes. Anything else is refused with `AGENT_SESSION_SCOPE`.
+     */
+    customerToken?: string;
     /** Called when an auth token is received from Vendure (e.g. after login). Use to persist the token. */
     onAuthToken?: (token: string) => void;
     /**
@@ -68,6 +140,38 @@ export interface StorefrontClientConfig {
      * fired on session expiry (that is `onAuthExpired`).
      */
     onAuthCleared?: () => void;
+    /**
+     * Called when the store this client serves turns out to have been renamed: the platform
+     * answered `storeCode` (or the code this client had switched to) under the store's NEW code.
+     * The client switches to the new code by itself — requests, feed and sitemap URLs, asset
+     * paths and cache tags all follow — but the old code stops answering at `previousCodeUntil`,
+     * so a process started after that on the old configuration finds no store. Update the
+     * configuration within that time.
+     *
+     * Unset: one `console.warn` per process naming the new code to configure. Called at most once
+     * per client for each rename; an error it throws (or a promise it returns that rejects) is
+     * logged, never thrown into a request. If the new code stops answering while the old one
+     * answers again as the same store (the rename was undone), the client switches back and this
+     * is called again with the codes the other way round.
+     *
+     * On a store router (`resolveStore`): called once per router for each rename. A router does
+     * NOT switch — it keeps resolving the code `resolveStore` names, and serves the store under it
+     * only until `previousCodeUntil`; update `resolveStore` (and any `stores` / `privateToken`
+     * entries) before then.
+     */
+    onStoreRenamed?: (rename: StoreRename) => void | Promise<void>;
+    /**
+     * Where this client's deprecation notices go: a deprecated method of this SDK
+     * (`kind: 'method'` — `client.graphql()`), or a platform route that answered with a
+     * `Deprecation` header (`kind: 'endpoint'`). Route them to your logger, or pass
+     * `() => {}` to silence them.
+     *
+     * Unset: printed with `console.warn` — a deprecated method ONCE PER PROCESS however many
+     * clients use it, a deprecated route once per client. Set: called once per client for each
+     * (once per router on `resolveStore`); an error it throws, or a promise it returns that
+     * rejects, is logged and never thrown into the call it observed.
+     */
+    onDeprecation?: (notice: StorefrontDeprecationNotice) => void;
     /**
      * Retry config for transient GET failures (network errors and 502/503/504).
      * Defaults to `{ attempts: 2, baseDelayMs: 200 }`. Set `attempts: 1` to
@@ -92,117 +196,97 @@ export interface StorefrontClientConfig {
      */
     orderScope?: OrderScope;
     /**
-     * Cache tags on product and collection reads, for Next.js `revalidateTag` —
-     * the tags `createEventRevalidateHandler` purges. The SDK adds
-     * `next: { tags }` to the fetch init (Next reads it; other fetch
-     * implementations ignore unknown init keys) and sets no cache policy:
-     * whether a request is cached stays your app's decision.
+     * Which of the store's heads this client speaks for, sent as `x-head` on every
+     * request — see {@link HeadKey}. Unset: the store's default head, which is
+     * exactly what every release before this option did.
      *
-     * - `true` (default): tags derived from each call's inputs — `product:<id>`
-     *   for `getProductById` and `getProductProperties`, `collection:<id>` for
-     *   `getCollectionById`, `getProductsInCollectionById` and `searchProducts`
-     *   with `collectionId`/`collectionIds`.
+     * It moves where emailed links point, NOT canonical URLs: `seo.canonicalFor`
+     * and the hreflang alternates are always built on the store's main shop
+     * address (`storefrontUrl`), whatever head the request names.
+     */
+    head?: HeadKey;
+    /**
+     * Cache tags on catalogue and menu reads, for Next.js `revalidateTag` — the
+     * tags `createEventRevalidateHandler` purges. The SDK adds `next: { tags }`
+     * to the fetch init (Next reads it; other fetch implementations ignore
+     * unknown init keys) and sets no cache policy: whether a request is cached
+     * stays your app's decision.
+     *
+     * - `true` (default): `catalog` on EVERY catalogue read (products,
+     *   collections, search, facets, property groups and properties,
+     *   recommendations), first in the list; plus tags derived from each call's
+     *   inputs — `product:<id>` for `getProductById` and `getProductProperties`,
+     *   `collection:<id>` for `getCollectionById`, `getProductsInCollectionById`
+     *   and `searchProducts` with `collectionId`/`collectionIds`, and
+     *   `menu:<id>` for `getMenu(id)`.
      * - `false`: no `next` key on any request.
-     * - a {@link CacheTagResolver}: decides per request.
+     * - a {@link CacheTagResolver}: decides per request; it sees `catalog` too.
      *
-     * Load pages by the id `findRoute` resolves and they are tagged. Raw slug
-     * reads (`getProduct(slug)`, `getCollection(slug)`,
-     * `getProductsInCollection(slug)`) stay untagged — the id is not known until
-     * the response arrives; pass `route.cacheTags` per request to tag one.
+     * Load pages by the id `findRoute` resolves and they carry their id tag.
+     * Raw slug reads (`getProduct(slug)`, `getCollection(slug)`,
+     * `getProductsInCollection(slug)`, `getMenu(slug)`) carry no id tag — the id
+     * is not known until the response arrives; pass `route.cacheTags` per
+     * request to tag one. The catalogue ones still carry `catalog`.
      */
     cacheTags?: boolean | CacheTagResolver;
-}
-/**
- * Storefront-visible Channel custom fields. Enumerates fields the SDK or its
- * consumers read directly. Unknown fields are still accessible via the index
- * signature, so adding a new field on the backend doesn't require an SDK
- * release for storefronts to consume it.
- */
-export interface ChannelCustomFields {
-    /** SDK consumes this to gate the entire client into read-only mode. */
-    maintenanceMode?: boolean;
-    /** Custom CDN domain for asset URLs (set per-channel via cdn-domain plugin). */
-    cdnDomain?: string | null;
-    /**
-     * Absolute URL of the storefront for this channel (e.g. `https://store.example.com`).
-     * Required by the SEO module to emit canonical URLs and hreflang tags.
-     */
-    storefrontUrl?: string;
-    /**
-     * URL strategy the storefront uses to encode the active language. Drives
-     * canonical/alternate URL generation in the SEO module.
-     */
-    urlLocaleStrategy?: 'path-prefix' | 'subdomain' | 'none';
-    /**
-     * When `true`, the URL still includes a locale prefix even for the channel's
-     * default language. When `false` (default), the default language URL has no
-     * prefix.
-     */
-    urlLocalePrefixDefault?: boolean;
-    businessName?: string | null;
-    businessDescription?: string | null;
-    logoAssetId?: string | null;
-    darkLogoAssetId?: string | null;
-    coverAssetId?: string | null;
-    faviconAssetId?: string | null;
-    websiteUrl?: string | null;
-    primaryColor?: string | null;
-    contactEmail?: string | null;
-    contactPhone?: string | null;
-    legalName?: string | null;
-    vatNumber?: string | null;
-    registrationNumber?: string | null;
-    addressLine1?: string | null;
-    addressLine2?: string | null;
-    city?: string | null;
-    postalCode?: string | null;
-    province?: string | null;
-    country?: string | null;
-    /** JSON-encoded social URLs map. Keys: facebook, instagram, twitter, linkedin, youtube, tiktok. */
-    socialLinks?: string | null;
-    commercePathPrefix?: string | null;
-    /** JSON-encoded `{ [languageCode]: pathPrefix }` per-locale overrides. */
-    commercePathPrefixTranslations?: string | null;
-    /** Segment canonical product URLs sit under. Unset/empty means `products`. */
-    productPathSegment?: string | null;
-    /** Channel default Twitter / X handle (without @). Used by `metaTagsFor()` for `twitter:site`. */
-    twitterHandle?: string | null;
-    /** Vendure Asset ID used as the fallback OpenGraph image when a product does not provide one. */
-    defaultOgImageId?: string | null;
-    /** When true, the storefront serves `/llms.txt` advertising AI-friendly endpoints. */
-    llmsTxtEnabled?: boolean;
-    /**
-     * When true, B2B customers can submit quote requests on this channel.
-     * Storefronts should gate quote UI (request-quote buttons, "My quotes"
-     * account section) on this flag instead of probing `createQuoteRequest`.
-     */
-    quotesEnabled?: boolean;
-    /**
-     * When true, customers can request order returns on this channel.
-     * Storefronts should gate return UI ("Request return" buttons, "My
-     * returns" account section) on this flag instead of probing
-     * `requestReturn`.
-     */
-    returnsEnabled?: boolean;
-    /** Days after delivery/shipment during which a return may be requested. */
-    returnWindowDays?: number;
-    /**
-     * Channel-wide display default: `channel` (follow `pricesIncludeTax`),
-     * `gross` or `net`. Raw storage value — read it with `parseTaxDisplayPolicy`
-     * and render from `pricing.getTaxDisplayMode()`, which resolves the whole
-     * policy server-side for the actual shopper.
-     */
-    taxDisplayDefault?: string | null;
-    /** B2B override: `inherit`, `gross` or `net`. See {@link taxDisplayDefault}. */
-    taxDisplayB2b?: string | null;
-    /**
-     * JSON array of ISO-3166 alpha-2 codes, e.g. `["US"]`. A shopper whose
-     * country is listed always sees prices excl. tax AND is taxed by their own
-     * country's tax zone. Empty/unset = the rule is off.
-     */
-    taxExclusiveCountries?: string | null;
-    /** Forward-compat: any additional storefront-visible custom fields. */
-    [key: string]: unknown;
+    /**
+     * A PRIVATE STOREFRONT TOKEN (`s69p_…`) for a SERVER-SIDE storefront — one per
+     * head, issued with `admin.heads.privateTokens.issue` from
+     * `@sixtyninecommerce/admin`. Sent as `x-storefront-token` on every Vendure,
+     * CMS and plugins call, beside the public channel token.
+     *
+     * It grants no permission. It gives the server its own rate-limit budget
+     * instead of the anonymous one, and makes the platform key per-shopper budgets
+     * (and the CMS form limiter) on the address in {@link buyerIp} — without it,
+     * every shopper of a server-rendered storefront shares the server's address.
+     *
+     * NEVER in a browser: `createStorefrontClient` throws `CREDENTIAL_IN_BROWSER`
+     * there, because a token a page holds is a token every visitor holds.
+     */
+    privateToken?: string;
+    /**
+     * The shopper every call is for — the address YOUR server saw the shopper
+     * connect from (e.g. the first untrusted `X-Forwarded-For` hop), one IPv4 or
+     * IPv6 address. Requires {@link privateToken}. Override it per call with
+     * `{ buyerIp }` in the request options, which is what a server rendering for
+     * many shoppers at once should do. The platform refuses a value that is not
+     * an address with `INVALID_BUYER_IP`.
+     */
+    buyerIp?: string;
+    /**
+     * Remember public CMS and plugins reads — menus, content strings, collections,
+     * the routes and capability manifests — and ask the server "has this changed?" (`If-None-Match`)
+     * instead of downloading them again. **On by default, except on Next.js's
+     * patched `fetch`** (below). The server is asked on every read, so nothing is
+     * ever served stale: an unchanged read comes back as a bodyless 304 and is
+     * answered from memory, parsed afresh for each caller. Identical reads in
+     * flight at the same moment share one request.
+     *
+     * - `true` (the default off Next): one cache per process, shared by every
+     *   client built on the same `fetch` — at most 500 reads and 5 MB, least
+     *   recently used first out. A storefront that builds a client per request
+     *   still benefits.
+     * - `{ maxEntries?, maxBytes? }`: a cache of this client's own, with these bounds.
+     * - `false` (the default on Next's `fetch`): every read downloads, as before.
+     *
+     * Never for anything signed in: Shop API calls (the cart, checkout, the
+     * customer's account, every price) are never cached, and the CMS and plugins
+     * reads never carry the shopper's session — they are the same request for a
+     * signed-in shopper as for a guest, so sharing them shares nothing personal.
+     * The cache key is everything the request sends (store, language, the private
+     * token, the query), so one store's or language's answer is never another's.
+     *
+     * **Next.js: off unless you ask.** When the `fetch` this client runs on (yours,
+     * or the global one) is Next's patched `fetch` — it carries `__nextPatched` —
+     * the default is `false`. This cache sits ABOVE that `fetch`, and Next's data
+     * cache lives inside it: Next keys a cached fetch on its request headers and
+     * stores only a 200, so the `If-None-Match` this cache adds would miss Next's
+     * entry and turn every render's zero-request hit into a 304 round trip. An app
+     * that does NOT cache its fetches with Next (no `cache: 'force-cache'`, segment
+     * `revalidate` or `fetchCache`) may pass `true` and gain from it. A wrapper
+     * around Next's `fetch` hides the marker: pass `false` yourself then.
+     */
+    conditionalReads?: ConditionalReadsOption;
 }
 export interface BrandingAssetRef {
     id: string;
@@ -284,6 +368,40 @@ export interface BrandingInfo {
     social: BrandingSocialLinks;
     storefront: BrandingStorefrontConfig;
 }
+/** A store's code moved (headless W8-16b): the code this client knew, and the one it uses now. */
+export interface StoreRename {
+    /** The code the client was configured with, or had followed to before. */
+    previousCode: string;
+    /** The store's current code: configure this one. */
+    code: string;
+    /** When the old code stops answering (ISO-8601), when the platform said. */
+    previousCodeUntil?: string;
+    /**
+     * `previousCode` had already stopped answering: the rename this client followed was undone
+     * (or the code it moved to was ended early), and it found the store again under `code`.
+     * Configure `code` now.
+     */
+    previousCodeGone?: boolean;
+}
+/** A method of this SDK that is going away (headless spec §11): `client.graphql()`. */
+export interface MethodDeprecationNotice {
+    readonly kind: 'method';
+    /** The method as a consumer calls it: `'client.graphql'`. */
+    readonly name: string;
+    /** What to call instead. */
+    readonly replacement: string;
+    /** The one line the client prints for it when no `onDeprecation` is configured. */
+    readonly message: string;
+}
+/**
+ * A platform route this client called answered with a `Deprecation` header — the route, the
+ * deprecation date, and the `Sunset` and replacement link when the platform sent them.
+ */
+export interface EndpointDeprecationNotice extends DeprecationNotice {
+    readonly kind: 'endpoint';
+}
+/** Something this client uses is going away: one of its methods, or a platform route. */
+export type StorefrontDeprecationNotice = MethodDeprecationNotice | EndpointDeprecationNotice;
 /** Channel info resolved from CMS at initialization. */
 export interface ChannelInfo {
     id: string;
@@ -298,11 +416,30 @@ export interface ChannelInfo {
      * net-vs-gross display decisions (e.g. a B2B/B2C BTW toggle).
      */
     pricesIncludeTax: boolean;
-    customFields: ChannelCustomFields;
+    /**
+     * The channel's public custom fields exactly as the CMS sends them: the keys
+     * it selects from the Shop API's `activeChannel`, each optional and nullable,
+     * and an empty bag while Vendure is unreachable. A key the CMS does not select
+     * is absent — read the Shop API's `commerce.getActiveChannel()` for those.
+     */
+    customFields: Cms.PublicChannelDto['custom_fields'];
+    /**
+     * Set when the channel was resolved through a renamed store's OLD code: that old code, which
+     * stops answering at {@link previousCodeUntil}. `code` is the current one.
+     */
+    previousCode?: string;
+    /** With {@link previousCode}: when the store was renamed away from it (ISO-8601). */
+    renamedAt?: string;
+    /** With {@link previousCode}: when the old code stops answering (ISO-8601). */
+    previousCodeUntil?: string;
 }
 /** Shared context used by all modules. */
 export interface StoreContext {
-    channel: ChannelInfo;
+    /**
+     * The store's channel. On a client, a getter over its CURRENT code: it moves when the store is
+     * renamed (`onStoreRenamed`), and is never assigned.
+     */
+    readonly channel: ChannelInfo;
     /**
      * The channel resolver the transport re-resolves through. `createStoreContext`
      * always sets it; a context assembled BY HAND (a test double) may leave it
@@ -316,7 +453,15 @@ export interface StoreContext {
     cmsUrl: string;
     pluginsUrl: string;
     languageCode: string;
+    /** The currency prices are formatted in: the session currency, else the channel default. */
     currencyCode: string;
+    /**
+     * The shopper's chosen currency, sent as `?currencyCode=` on every Shop API
+     * request; `null`/absent sends nothing (the channel default). Set from
+     * {@link StorefrontClientConfig.currencyCode} and by
+     * `commerce.setOrderCurrency`; reset when the engine refuses it.
+     */
+    sessionCurrencyCode?: string | null;
     /** Channel tax-display storage mode — see {@link ChannelInfo.pricesIncludeTax}. */
     pricesIncludeTax: boolean;
     authToken: string | null;
@@ -326,6 +471,30 @@ export interface StoreContext {
      * {@link StorefrontClientConfig.orderScope}.
      */
     orderScope?: OrderScope | null;
+    /**
+     * The head key sent as `x-head`, or `null`/absent for none (the store's
+     * default head). See {@link StorefrontClientConfig.head}.
+     */
+    head?: string | null;
+    /**
+     * Set by a multi-store client (`createStorefrontClient({ resolveStore })`):
+     * every cache tag a read carries is also sent scoped to the store,
+     * `store:<code>:<tag>`, beside the bare tag. Treat as internal.
+     */
+    storeScopedCacheTags?: boolean;
+    /**
+     * Set by a multi-store client: one deprecation reporter for every request's
+     * transports, so a deprecated route is announced once per router rather than
+     * once per request. Absent: each transport's own reporter. Treat as internal.
+     */
+    onDeprecation?: (notice: DeprecationNotice) => void;
+    /**
+     * Who hears that a deprecated method of this SDK was used (`client.graphql()`): the
+     * configured `onDeprecation`, once per client — shared by a multi-store client's
+     * per-request clients, so once per router. Absent: the process-wide default line. Treat as
+     * internal.
+     */
+    reportDeprecatedMethod?: (notice: MethodDeprecationNotice) => void;
     /**
      * Last resolved tax display mode, cached against the identity it was resolved
      * for (see `identityStamp`). Owned by `pricing.getTaxDisplayMode()`; cleared
@@ -343,6 +512,16 @@ export interface StoreContext {
     };
     /** See {@link StorefrontClientConfig.cacheTags}. Absent means `true`. */
     cacheTags?: boolean | CacheTagResolver;
+    /** See {@link StorefrontClientConfig.privateToken}. Null for a public client. */
+    privateToken?: string | null;
+    /** See {@link StorefrontClientConfig.buyerIp}. */
+    buyerIp?: string | null;
+    /**
+     * See {@link StorefrontClientConfig.conditionalReads}: `createStoreContext`
+     * resolves the default (off on Next's patched `fetch`, else on). Absent — a
+     * context built by hand — means `true`. CMS and plugins transport only.
+     */
+    conditionalReads?: ConditionalReadsOption;
 }
 export interface GraphQLResponse<T = unknown> {
     data: T;
@@ -354,12 +533,6 @@ export interface GraphQLResponse<T = unknown> {
         };
     }>;
 }
-export interface AgeVerificationStatus {
-    required: boolean;
-    minimumAge: number | null;
-    verified: boolean;
-    dateOfBirth: string | null;
-}
 export interface AssetPresetSize {
     url: string;
     webpUrl: string;
@@ -380,48 +553,10 @@ export interface Asset {
     /** Intrinsic pixel height of the source image. Absent when not selected. */
     height?: number | null;
     customFields?: {
-        altText?: string;
-        contentHash?: string;
-    };
-    presets?: AssetPresets;
-}
-export interface CmsAssetTranslation {
-    language_code: string;
-    alt_text: string | null;
-}
-/** Public-safe CMS asset returned by /assets/lookup, /public-assets/:id. */
-export interface CmsAsset {
-    id: string;
-    filename: string;
-    mime_type: string;
-    file_size: number;
-    storage_key: string;
-    content_hash: string | null;
-    width: number | null;
-    height: number | null;
-    alt_text: string | null;
-    presets: Record<PresetName, {
-        url: string;
-        webp_url: string;
-        width: number;
-        height: number;
-    }> | null;
-    translations: CmsAssetTranslation[];
-}
-export interface VendureAssetDescriptionTranslation {
-    language_code: string;
-    description: string;
-}
-export interface PriceTier {
-    minQuantity: number;
-    price: number;
-    priceWithTax: number;
-    discountLabel: string | null;
-}
-export interface VariantLocationAvailability {
-    locationId: string;
-    locationName: string;
-    inStock: boolean;
+        altText?: string | null;
+        contentHash?: string | null;
+    } | null;
+    presets?: AssetPresets | null;
 }
 /**
  * A merchant's publication state for a product that is launched but not simply
@@ -439,405 +574,67 @@ export interface VariantLocationAvailability {
  * handle and treat everything else as `'none'` — every helper in
  * `@sixtyninecommerce/client/pricing` does exactly that.
  */
-export type ProductAvailabilityState = 'none' | 'comingSoon' | 'preorder';
+export type ProductAvailabilityState = Shop.ProductAvailabilityState;
+export type { AddItemInput, AdjustmentType, AuthenticationInput, BreadcrumbFragment, ChannelCustomFieldsFragment, CollectionDetailFragment, CollectionFragment, CollectionRefFragment, ConvertedAmountFragment, CreateAddressInput, CreateCustomerInput, CreateProductReviewInput, CreateQuoteRequestInput, CreditBalanceSource, CurrencyCode, CurrentUserFragment, CustomerPaymentTermsFragment, CustomerReturnFragment, CustomerSubscriptionFragment, DeliveryAdvice, DeliverySelectionSource, DeliveryTermsStatus, DepositPaymentIntentInput, FacetFragment, FacetValueFragment, FavoriteListOptions, LanguageCode, MolliePaymentIntentInput, MolliePaymentMethodsInput, MyPaymentMandateFragment, MyparcelDeliveryOptionsInput, MyparcelDropOffPointInput, NativeAuthInput, OrderDeliveryTermsFragment, OrderFragment, OrderFulfillmentParcelsFragment, OrderFulfillmentsFragment, OrderPaymentIntent, OrderPaymentTermsFragment, OrderReturnReasonCode, OrderReturnSettlementMethod, OrderReturnState, OrderSummaryFragment, OrderWritableCustomFieldsFragment, ParkedOrderFragment, ParkedOrderPaymentIntentInput, PayDepositInput, PaymentInput, PaymentTermsClassification, PaymentTermsStatus, PayParkedOrderInput, PickupLocationSearchInput, PlacementRejectionFragment, PriceTierFragment, ProductAvailabilityFragment, ProductCardFragment, ProductFragment, ProductMetadataFragment, ProductPropertyGroupValuesFragment, ProductReviewFragment, ProductReviewListOptions, ProductSummaryFragment, ProductVariantFragment, PropertyGroupFragment, PublicPaymentMethodFragment, PublicShippingMethodFragment, QuoteFragment, QuoteLegacyFragment, QuoteLineDiscountType, QuoteLineRequestInput, QuoteListOptions, QuoteStatus, RecentReviewsOptions, RecommendedProductGroupFragment, RegisterCustomerInput, RequestReturnInput, ReturnRequestLineInput, ReviewSortKey, ReviewStatus, SavedListFragment, SearchResultFragment, SearchResultItemFragment, SetupPaymentMandateInput, SubscriptionFirstChargeTiming, SubscriptionPlanPublicFragment, SubscriptionPurchaseResultFragment, UpdateAddressInput, UpdateCustomerInput, UpdateOrderCustomFieldsInput, UpdateProductReviewInput, VariantLocationAvailabilityFragment, VatValidationResultFragment, } from './generated/shop.js';
+/** A strategy `commerce.authenticate` can sign in through: a member of the engine's `AuthenticationInput` (`native` today). */
+export type AuthenticationStrategy = keyof Shop.AuthenticationInput;
+/** What a strategy takes — `{ username, password }` for `native`. */
+export type AuthenticationStrategyInput<S extends AuthenticationStrategy> = NonNullable<Shop.AuthenticationInput[S]>;
 /**
- * The availability state in force, resolved server-side against the moment of
- * the request: a launch date that has already passed always reads
- * `state: 'none'` with `availableFrom: null`, so there is no stale window for a
- * storefront to compensate for.
+ * A product as `getProduct` / `getProductById` return it: the generated
+ * {@link ProductFragment} with `metadata` parsed and validated at the SDK
+ * boundary (its JSON-scalar members arrive as `unknown` on the wire).
+ * `null` when no metadata has been authored for the product on this channel.
  *
- * Buyer-independent and **cacheable** — the exact opposite of
- * `backorderAllowance`. It is a merchant publication state, identical for an
- * anonymous visitor and a signed-in B2B buyer, so a page carrying it may sit in
- * a shared or CDN cache. See `docs/storefront/preorders.md`.
+ * `availability` is the PRODUCT's own publication state, ignoring any variant
+ * override — the banner for a detail page. What applies to the variant about to
+ * be added is `variant.availability`, which is what the buy button reads.
  */
-export interface ProductAvailability {
-    state: ProductAvailabilityState;
-    /**
-     * When the state ends on its own, ISO 8601. `null` for `'none'` and for a
-     * state the merchant ends by hand.
-     */
-    availableFrom: string | null;
-    /**
-     * Whether the merchant accepts orders for this at all — `false` only for
-     * `'comingSoon'`.
-     *
-     * NOT a stock verdict, and **not a buy-button gate on its own**: an anonymous
-     * shopper sees `orderable: true` on a `'preorder'` variant they still cannot
-     * order beyond stock, because ordering beyond stock needs `backorderAllowance`.
-     * Combine the two — `canAddToCart(variant)` does.
-     */
-    orderable: boolean;
-}
-export interface ProductOption {
-    id: string;
-    code: string;
-    name: string;
-    group: {
-        id: string;
-        name: string;
-        code: string;
-    };
-}
-export interface ProductVariant {
-    id: string;
-    name: string;
-    sku: string;
-    price: number;
-    priceWithTax: number;
-    currencyCode: string;
-    stockLevel: string;
-    /**
-     * Physical on-hand stock across the channel's locations. `null` when the
-     * channel does not expose operational stock numbers (the default) — fall
-     * back to the `stockLevel` string.
-     */
-    stockOnHand: number | null;
-    /** Stock reserved by open orders. `null` when the channel does not expose it. */
-    stockAllocated: number | null;
-    /**
-     * Units a customer can actually order right now (available-to-promise).
-     * `null` when the channel does not expose operational stock numbers.
-     */
-    saleable: number | null;
-    /**
-     * Units already on order from suppliers (e.g. open Exact purchase orders).
-     * `null` unless the channel exposes stock AND the signed-in customer's group
-     * may see incoming stock — anonymous visitors always get `null`.
-     */
-    incomingStock: number | null;
-    /** Forward-looking `max(0, saleable) + incomingStock`. Same gate as `incomingStock`. */
-    projectedSaleable: number | null;
-    /**
-     * Earliest FUTURE expected warehouse arrival, ISO 8601. Never a past date.
-     * `null` under the same gate as `incomingStock`, and ALSO when no open line
-     * has a future date — so `incomingStock > 0` with `nextExpectedArrival: null`
-     * is normal (on order, but every date is overdue or missing). Show a dateless
-     * "restock on order" hint then. This is a warehouse-arrival estimate, never a
-     * delivery promise.
-     */
-    nextExpectedArrival: string | null;
-    /**
-     * Units BEYOND `saleable` the signed-in customer may order on backorder right
-     * now. The quantity ceiling is `max(0, saleable) + backorderAllowance` (see
-     * `maxOrderableQuantity` in `@sixtyninecommerce/client/pricing`). `null` when
-     * the question does not apply — anonymous, group may not backorder, or the
-     * channel hides stock — treat exactly like today; `0` = denied; a large
-     * value (2,000,000,000) is the "unlimited" sentinel. A snapshot: the server
-     * re-checks on add-to-cart and at placement and refuses with the usual
-     * `InsufficientStockError` / `INSUFFICIENT_STOCK`, whose `quantityAvailable`
-     * then already includes the allowance.
-     */
-    backorderAllowance: number | null;
-    priceListName: string | null;
-    retailPrice: number | null;
-    retailPriceWithTax: number | null;
-    /** Tax rate applied to this price in the active channel/zone, e.g. `{ value: 21 }` for 21% VAT. */
-    taxRateApplied: {
-        value: number;
-    } | null;
-    priceTiers: PriceTier[] | null;
-    /**
-     * The merchant's publication state in force for this variant — its own
-     * override when it has one, otherwise its product's — resolved against the
-     * moment of the request. Never `null`: an unset product reads
-     * `{ state: 'none', availableFrom: null, orderable: true }`.
-     *
-     * Ungated and buyer-independent, unlike `backorderAllowance`: every shopper
-     * sees the same value and a response carrying it is cacheable.
-     */
-    availability: ProductAvailability;
-    availabilityByLocation: VariantLocationAvailability[];
-    options: ProductOption[];
-    featuredAsset: Asset | null;
-    assets: Asset[];
-    customFields: {
-        minOrderQuantity: number | null;
-        salesUnit: number | null;
-        position: number | null;
-    };
-}
-export interface FacetValue {
-    id: string;
-    name: string;
-    code: string;
-    facet: {
-        id: string;
-        name: string;
-        code: string;
-    };
-}
-export interface CollectionRef {
-    id: string;
-    name: string;
-    slug: string;
-    position?: number;
-    /**
-     * The parent's `slug` is load-bearing, not decoration: a top-level collection
-     * is parented to the `__root_collection__` SENTINEL (Vendure resolves `parent`
-     * to null only when the real parent is PRIVATE), so the slug is what
-     * distinguishes "this is a root" from "this is nested". The SDK's own product
-     * queries select it. A caller writing its own query and omitting it gets the
-     * flat product path for every canonical — see `isUserFacingRoot`.
-     */
-    parent?: {
-        id: string;
-        slug?: string;
-    } | null;
-    translations?: Array<{
-        languageCode: string;
-        name: string;
-        slug: string;
-    }>;
-    customFields?: {
-        isRoutable?: boolean | null;
-        isCanonical?: boolean | null;
-    } | null;
-}
-export interface ProductTranslation {
-    languageCode: string;
-    name: string;
-    slug: string;
-    description?: string;
-}
-export interface OptionGroup {
-    id: string;
-    name: string;
-    code: string;
-    options: Array<{
-        id: string;
-        name: string;
-        code: string;
-    }>;
-}
-export interface PublicProductDocument {
-    id: string;
-    position: number;
-    title: string;
-    description: string | null;
-    fileUrl: string;
-    fileMimeType: string;
-    fileSize: number;
-    fileName: string;
-    /** When true, the URL is presigned and short-lived. Don't cache it. */
-    requiresAuth: boolean;
-}
-export interface Product {
-    id: string;
-    name: string;
-    slug: string;
-    description: string;
-    featuredAsset: Asset | null;
-    assets: Asset[];
-    variants: ProductVariant[];
-    /**
-     * The PRODUCT's own publication state, ignoring any variant override — the
-     * banner for a detail page ("Pre-order, ships from 12 March"). What applies to
-     * the variant the shopper is about to add is `variant.availability`, which is
-     * the one the buy button reads.
-     */
-    availability: ProductAvailability;
-    optionGroups: OptionGroup[];
-    facetValues: FacetValue[];
-    collections: CollectionRef[];
-    translations?: ProductTranslation[];
-    documents?: PublicProductDocument[];
-    /**
-     * Per-product SEO/social/AI metadata. Resolved server-side for the active
-     * language and validated client-side at the SDK boundary. `null` when no
-     * metadata has been authored for this product on the current channel.
-     */
-    metadata?: import('./seo/metadata-types.js').ProductMetadata | null;
-}
-export interface RecommendedProductGroup {
-    groupName: string;
-    groupSlug: string;
-    products: ProductSummary[];
-}
-export interface ProductSummary {
-    id: string;
-    name: string;
-    slug: string;
-    description?: string;
-    /** Whether the product is enabled on the channel. Selected by `LIST_PRODUCTS`. */
-    enabled?: boolean;
-    featuredAsset: Asset | null;
-    variants: Array<{
-        id: string;
-        name?: string;
-        sku?: string;
-        price: number;
-        priceWithTax: number;
-        currencyCode: string;
-        stockLevel: string;
-        /** ATP numbers — `null` when the channel does not expose operational stock. */
-        stockOnHand?: number | null;
-        stockAllocated?: number | null;
-        saleable?: number | null;
-        /**
-         * Incoming-stock numbers — additionally `null` unless the signed-in customer's
-         * group may see incoming stock. `nextExpectedArrival` is the earliest FUTURE
-         * arrival (ISO 8601, never past) and is `null` when every open line is overdue,
-         * even while `incomingStock > 0`.
-         */
-        incomingStock?: number | null;
-        projectedSaleable?: number | null;
-        nextExpectedArrival?: string | null;
-        /** Units beyond `saleable` this buyer may backorder; `null` = not applicable. */
-        backorderAllowance?: number | null;
-        /**
-         * The merchant's publication state in force for this variant. Selected by
-         * both `LIST_PRODUCTS` and the card selection, because a grid that labels a
-         * pre-orderable SKU "out of stock" is the bug this field exists to stop.
-         *
-         * Optional like every other additive field on this summary shape, and
-         * nullable because the deprecated `getProducts({ collectionSlug })` path
-         * synthesises these rows from SEARCH hits, which carry `null` until the
-         * channel has had a full reindex.
-         */
-        availability?: ProductAvailability | null;
-        availabilityByLocation?: VariantLocationAvailability[];
-        priceListName?: string | null;
-        retailPrice?: number | null;
-        retailPriceWithTax?: number | null;
-        taxRateApplied?: {
-            value: number;
-        } | null;
-        priceTiers?: PriceTier[] | null;
-        customFields?: {
-            minOrderQuantity: number | null;
-            salesUnit: number | null;
-            position: number | null;
-        };
-    }>;
-    facetValues?: FacetValue[];
-    collections?: CollectionRef[];
-}
-export interface Facet {
-    id: string;
-    name: string;
-    code: string;
-    values: Array<{
-        id: string;
-        name: string;
-        code: string;
-    }>;
-}
-export interface Breadcrumb {
-    id: string;
-    name: string;
-    slug: string;
-}
-/** Per-language translation of a collection, including SEO custom fields. */
-export interface CollectionTranslation {
-    languageCode: string;
-    name?: string;
-    slug: string;
-    customFields?: {
-        seoTitle?: string | null;
-        seoDescription?: string | null;
-        canonicalUrl?: string | null;
-        socialTitle?: string | null;
-        socialDescription?: string | null;
-        socialImageAlt?: string | null;
-    } | null;
-}
-/** Collection-scoped custom fields: routing directives + SEO scalars. */
-export interface CollectionCustomFields {
-    isRoutable?: boolean | null;
-    isCanonical?: boolean | null;
-    noindex?: boolean | null;
-    nofollow?: boolean | null;
-    metaRobotsMaxImagePreview?: string | null;
-    socialImageId?: string | null;
-    socialOgType?: string | null;
-    twitterCardType?: string | null;
-}
-export interface Collection {
-    id: string;
-    name: string;
-    slug: string;
-    description?: string;
-    position?: number;
-    featuredAsset?: Asset | null;
-    breadcrumbs?: Breadcrumb[];
-    parent?: CollectionRef | null;
-    children?: CollectionRef[];
-    customFields?: CollectionCustomFields | null;
-    translations?: CollectionTranslation[];
-}
-export interface CollectionDetail extends Collection {
-    productVariants?: {
-        items: Array<{
-            id: string;
-            product: ProductSummary;
-            price: number;
-            priceWithTax: number;
-            currencyCode: string;
-            stockLevel: string;
-            /** ATP numbers — `null` when the channel does not expose operational stock. */
-            stockOnHand: number | null;
-            stockAllocated: number | null;
-            saleable: number | null;
-            /**
-             * Incoming-stock numbers — additionally `null` unless the signed-in customer's
-             * group may see incoming stock. `nextExpectedArrival` is the earliest FUTURE
-             * arrival (ISO 8601, never past) and is `null` when every open line is overdue,
-             * even while `incomingStock > 0`.
-             */
-            incomingStock: number | null;
-            projectedSaleable: number | null;
-            nextExpectedArrival: string | null;
-            /** Units beyond `saleable` this buyer may backorder; `null` = not applicable. */
-            backorderAllowance: number | null;
-            /**
-             * The merchant's publication state in force for this variant. NON-null,
-             * unlike `CollectionProductVariant`: these rows come from
-             * `Collection.productVariants`, a real variant read on the Shop API, not
-             * from a search document that may predate the attribute — so the same
-             * rules as `ProductVariant.availability` apply, `{ state: 'none' }`
-             * included when nothing is set.
-             */
-            availability: ProductAvailability;
-            priceListName: string | null;
-            retailPrice: number | null;
-            retailPriceWithTax: number | null;
-            taxRateApplied: {
-                value: number;
-            } | null;
-            priceTiers: PriceTier[] | null;
-            availabilityByLocation: VariantLocationAvailability[];
-            customFields: {
-                minOrderQuantity: number | null;
-                salesUnit: number | null;
-                position: number | null;
-            };
-        }>;
-        totalItems: number;
-    };
-}
+export type Product = Omit<Shop.ProductFragment, 'metadata'> & {
+    metadata: ProductMetadata | null;
+};
 /**
  * Stable, append-only vocabulary for why an order could not be placed — or why
- * a payment was refused before it was taken.
+ * a payment was refused before it was taken: the Shop API's own enum, which a
+ * spec keeps equal to the platform's
+ * (`@sixtynine-digital/commerce-shared/placement-rejection`).
  *
  * Branch on this instead of keyword-matching `transitionError` /
  * `paymentErrorMessage`: that prose is operator English, is re-worded per
- * merchant, and is translated. This list is a deliberate copy of the
- * platform's (`@sixtynine-digital/commerce-shared/placement-rejection`) so the
- * published client stays zero-dependency; a spec asserts the two match.
+ * merchant, and is translated.
  *
  * Treat an unrecognised value defensively — always give your `switch` a
  * `default:` branch and fall back to `MutationError.message`. Codes are added
  * over time, and the SDK deliberately passes a code it does not know through
  * unchanged rather than rewriting it to `UNKNOWN`.
+ *
+ * - `HOOK_REJECTED` — an app the store installed refused the order (its
+ *   `order.validate` hook). `customerMessage` is the app's own sentence for the
+ *   buyer.
+ * - `HOOK_UNAVAILABLE` — an app the store installed could not confirm the order
+ *   right now; the order is refused until it can. Ask the buyer to try again
+ *   later.
+ * - `TAX_CHANGED` — the store's tax provider now calculates different tax for
+ *   this order, and the order already CARRIES it: re-read the order, show the
+ *   buyer the new total, and place it again — that attempt goes through. Not an
+ *   outage.
+ * - `VARIANT_NOT_FOR_SALE_IN_CURRENCY` — the cart holds products the store does
+ *   not sell in the order's currency (`currencyCode`; `lines` names them). The
+ *   buyer removes them or checks out in another currency. A product's
+ *   `forSaleInCurrency` says so before it reaches the cart, and adding one is
+ *   refused with the same code.
+ * - `PRODUCT_EXCLUDED_FROM_STORE` — the cart holds products the store no longer
+ *   sells (`lines` names them; the store stopped offering a product its
+ *   organization shares). The buyer removes them. Adding one is refused with the
+ *   same code.
  */
-export type PlacementRejectionCode = 'ORDER_EMPTY' | 'CUSTOMER_REQUIRED' | 'SHIPPING_METHOD_REQUIRED' | 'INSUFFICIENT_STOCK' | 'ORDER_MINIMUM_AMOUNT_NOT_MET' | 'ORDER_MINIMUM_QUANTITY_NOT_MET' | 'FULFILLMENT_MINIMUM_NOT_MET' | 'LINE_MINIMUM_QUANTITY_NOT_MET' | 'LINE_SALES_UNIT_NOT_MET' | 'SHIPPING_ADDRESS_INCOMPLETE' | 'SHIPPING_COUNTRY_NOT_SERVED' | 'AGE_VERIFICATION_REQUIRED' | 'AGE_REQUIREMENT_NOT_MET' | 'DELIVERY_TERMS_UNAVAILABLE' | 'PAYMENT_TERMS_UNAVAILABLE' | 'PAYMENT_INTENT_MISMATCH' | 'PLACEMENT_BLOCKED' | 'UNKNOWN';
+export type PlacementRejectionCode = Shop.PlacementRejectionCode;
 /**
  * An order line implicated in a rejection — the line below its minimum
  * quantity, the line that ran short of stock.
  *
  * The engine caps a rejection at 20 lines (`PlacementRejection.linesTruncated`
- * says when it did). Every field except the variant id is nullable, so render
+ * says when it did). Every field except the variant id is optional, so render
  * defensively; `productName`/`productVariantName` are already translated.
  */
 export interface PlacementRejectionLine {
@@ -851,458 +648,42 @@ export interface PlacementRejectionLine {
     quantityAvailable?: number | null;
 }
 /**
- * Field-level detail, e.g. which part of the shipping address is unusable.
+ * The structured, customer-safe half of a placement rejection: the generated
+ * {@link PlacementRejectionFragment} as `readPlacement` hands it on — `code`
+ * widened past the enum (a code this build predates passes through unchanged)
+ * and `lines` rebuilt as {@link PlacementRejectionLine}s (an entry naming no
+ * variant is dropped). A field-level detail (`details[number]`) says, e.g.,
+ * which part of the shipping address is unusable; its `field` is null when the
+ * detail is about the order as a whole.
  *
- * Deliberately NOT `FieldError` (the CMS form-validation shape): `field` is
- * nullable here, because a detail may be about the order as a whole.
+ * `customerMessage` is plain shopper English and safe to render as-is (null when
+ * the veto site supplied none); the operator prose stays on the error's own
+ * reason field for merchant-facing surfaces. The metadata fields are populated
+ * per code (e.g. `requiredAmount` + `amountBasis` — `net` or `gross` — for a
+ * minimum-amount rejection, in minor units of `currencyCode`) and are null
+ * otherwise. `linesTruncated` is true when `lines` was capped.
  */
-export interface PlacementRejectionDetail {
-    field?: string | null;
-    code?: string | null;
-    message: string;
-}
-/**
- * The structured, customer-safe half of a placement rejection.
- *
- * `customerMessage` is plain shopper English and safe to render as-is; the
- * operator prose stays on the error's own reason field for merchant-facing
- * surfaces. The metadata fields are populated per code (e.g. `requiredAmount` +
- * `amountBasis` for a minimum-amount rejection) and are null otherwise.
- */
-export interface PlacementRejection {
+export type PlacementRejection = Omit<Shop.PlacementRejectionFragment, 'code' | 'lines'> & {
     /**
-     * Widened past the union on purpose: the SDK passes a code it does not know
+     * Widened past the enum on purpose: the SDK passes a code it does not know
      * through unchanged, so an exhaustive `switch` must still have a `default:`.
      */
     code: PlacementRejectionCode | (string & {});
-    /** Shopper-safe sentence. Null when the veto site supplied none. */
-    customerMessage?: string | null;
-    lines?: PlacementRejectionLine[] | null;
-    details?: PlacementRejectionDetail[] | null;
-    /** True when `lines` was capped and does not list every affected line. */
-    linesTruncated: boolean;
-    /** Minor units, in `currencyCode`. */
-    requiredAmount?: number | null;
-    currencyCode?: string | null;
-    /** `net` or `gross` — which basis `requiredAmount` is expressed in. */
-    amountBasis?: string | null;
-    requiredQuantity?: number | null;
-    priceListName?: string | null;
-    salesUnit?: number | null;
-    minimumAge?: number | null;
-}
-export type AdjustmentType = 'PROMOTION' | 'DISTRIBUTED_ORDER_PROMOTION' | 'OTHER';
-export interface Discount {
-    /** Identifier of the source (e.g. promotion code or shipping method id). */
-    adjustmentSource: string;
-    type: AdjustmentType | string;
-    description: string;
-    /** Pre-tax discount amount in minor units. Negative values reduce the price. */
-    amount: number;
-    amountWithTax: number;
-}
-export interface OrderTaxSummary {
-    description: string;
-    /** Tax rate as a percentage (e.g. 21 for 21%). */
-    taxRate: number;
-    /** Net total to which this tax rate applies, in minor units. */
-    taxBase: number;
-    /** Tax total at this rate, in minor units. */
-    taxTotal: number;
-}
-export interface OrderPromotion {
-    id: string;
-    name: string;
-    description: string;
-    couponCode: string | null;
-}
-export interface OrderLine {
-    id: string;
-    quantity: number;
-    /**
-     * Units of this line physical stock did NOT cover when the order was placed
-     * (the part the merchant ships later). Stamped at placement, never
-     * decremented as the line ships — the fulfilments record what arrived.
-     *
-     * Selected by the PLACED-order reads alone (`getOrderByCode`,
-     * `getCustomerOrders`), so it is `undefined` from the cart reads and
-     * mutations: a cart line has no stamp to carry, and selecting it in the
-     * shared fragment would couple every cart call to an engine that has the
-     * field.
-     */
-    backorderedQuantity?: number;
-    unitPrice: number;
-    unitPriceWithTax: number;
-    /** Tax rate applied to this line as a percentage (e.g. 21 for 21%). */
-    taxRate: number;
-    linePrice: number;
-    linePriceWithTax: number;
-    /** Line price after item-level discounts, excluding tax. */
-    discountedLinePrice: number;
-    discountedLinePriceWithTax: number;
-    /** Discounts applied to this line (item-level promotions). */
-    discounts: Discount[];
-    productVariant: {
-        id: string;
-        name: string;
-        sku: string;
-        /**
-         * Units the channel will sell right now, `null` when it hides stock. Here
-         * so a cart can show how much of a line is on backorder BEFORE placement,
-         * when `backorderedQuantity` is still 0 — through
-         * `pricing.backorderedQuantityForCart(variant, quantity)`, which yields no
-         * hint at all when this is `null` (never read `null` as 0).
-         */
-        saleable: number | null;
-        product: {
-            id: string;
-            name: string;
-            slug: string;
-        };
-        options: Array<{
-            id: string;
-            name: string;
-            group: {
-                name: string;
-            };
-        }>;
-    };
-    featuredAsset: Asset | null;
-}
-export interface OrderAddress {
-    fullName: string;
-    company?: string;
-    streetLine1: string;
-    streetLine2?: string;
-    city: string;
-    province?: string;
-    postalCode: string;
-    countryCode: string;
-    phoneNumber?: string;
-}
-export interface FulfillmentLine {
-    orderLineId: string;
-    quantity: number;
-}
-/**
- * A shipment created for (part of) an order. `trackingCode` is the carrier
- * barcode — feed it to `commerce.trackShipment(trackingCode, postalCode)`
- * for live tracking history.
- */
-export interface Fulfillment {
-    id: string;
-    /** Fulfillment FSM state, e.g. Pending, Shipped, Delivered, Cancelled. */
-    state: string;
-    /** Human-readable fulfillment/shipping method description. */
-    method: string;
-    trackingCode: string | null;
-    createdAt: string;
-    updatedAt: string;
-    lines: FulfillmentLine[];
-}
-/**
- * A payment recorded against an order. `method` is the payment-method *code*
- * (e.g. `manual-payment`, `mollie-payment`) — drives storefront invoice-vs-PSP
- * routing. `transactionId` is the PSP receipt; null for manual/offline methods.
- */
-export interface OrderPayment {
-    id: string;
-    /** Payment-method code, e.g. `mollie-payment` or `manual-payment`. */
-    method: string;
-    /** Amount captured by this payment, in minor units. */
-    amount: number;
-    /** Payment FSM state, e.g. Authorized, Settled, Declined, Cancelled. */
-    state: string;
-    /** PSP transaction reference; null for manual/offline payments. */
-    transactionId: string | null;
-}
-/**
- * A shipping charge applied to an order. The selected method's name/code feeds
- * order-detail rendering; `priceWithTax` is the charged amount in minor units.
- */
-export interface ShippingLine {
-    shippingMethod: {
-        id: string;
-        name: string;
-        code: string;
-    };
-    priceWithTax: number;
-}
-export interface Order {
-    id: string;
-    code: string;
-    state: string;
-    active: boolean;
-    /** When the order (cart) was created — ISO-8601 instant. */
-    createdAt: string;
-    /** When the order left the cart state (was placed) — ISO-8601 instant; null while still an active cart. */
-    orderPlacedAt: string | null;
-    totalQuantity: number;
-    subTotal: number;
-    subTotalWithTax: number;
-    shipping: number;
-    shippingWithTax: number;
-    total: number;
-    totalWithTax: number;
-    currencyCode: string;
-    lines: OrderLine[];
-    /** Order-level discounts (e.g. order-total promotions, free shipping). */
-    discounts: Discount[];
-    /** Tax breakdown grouped by tax rate. */
-    taxSummary: OrderTaxSummary[];
-    /** Promotions applied to this order. */
-    promotions: OrderPromotion[];
-    /** Shipping charges on the order (selected method + charged price). */
-    shippingLines: ShippingLine[];
-    /** Payments recorded against the order (method code, state, PSP receipt). */
-    payments: OrderPayment[];
-    shippingAddress?: OrderAddress;
-    billingAddress?: OrderAddress;
-    customer?: {
-        id: string;
-        firstName: string;
-        lastName: string;
-        emailAddress: string;
-    };
-    couponCodes: string[];
-    /**
-     * Shipments for this order. Only selected on placed-order reads
-     * (`getOrderByCode`, customer order history) — absent on cart operations.
-     */
-    fulfillments?: Fulfillment[] | null;
-    /**
-     * Tracking pushed by an external fulfilment system, oldest delivery first.
-     * Prefer this over `fulfillments[].trackingCode` for display: one fulfilment can
-     * cover several parcels, which a single tracking code cannot express.
-     */
-    externalShipments?: ExternalShipment[] | null;
-    /** Immutable source-aware payment condition captured when this order was accepted. */
-    paymentTerms?: OrderPaymentTermsSnapshot | null;
-    /** Immutable Exact-aware delivery terms captured when this order was accepted. */
-    deliveryTerms?: OrderDeliveryTermsSnapshot | null;
-    /**
-     * Order-level custom fields.
-     *
-     * Only populated on the order returned by
-     * {@link CommerceModule.setPaymentIntent | commerce.setPaymentIntent} —
-     * ordinary cart and order reads do not select it, so that a client release
-     * cannot break every cart operation against an engine that predates a field.
-     * Keep the buyer's chosen intent in your own state; that call's response is
-     * where to read it back.
-     */
-    customFields?: OrderCustomFields | null;
-}
-/**
- * How the buyer said they would settle this order.
- *
- * `pay_now` = paid immediately (iDEAL, card, …), which is what a pay-now
- * discount promotion looks for; `on_account` = pay later on the net terms the
- * account carries. Written only by
- * {@link CommerceModule.setPaymentIntent | commerce.setPaymentIntent}, which
- * re-prices the order in the same call.
- */
-export type OrderPaymentIntentValue = 'pay_now' | 'on_account';
-/** The Shop API enum accepted by `commerce.setPaymentIntent`. */
-export type OrderPaymentIntent = 'PAY_NOW' | 'PAY_ON_ACCOUNT';
-export interface OrderCustomFields {
-    /**
-     * The buyer's stated payment intent, or `null` when they never stated one.
-     * Read-only: the only write path is `commerce.setPaymentIntent`.
-     */
-    paymentIntent?: OrderPaymentIntentValue | null;
-}
-/**
- * One parcel, pallet or pickup instruction pushed by the external fulfilment
- * system.
- *
- * `reference` is overloaded by design, because the sending systems overload it:
- * a parcel carrier sends a tracking URL, a pallet carrier sends a URL *or* a
- * plain reference, and ex-works sends free-text pickup instructions. Branch on
- * {@link ExternalShipment.isLink} — derived server-side — to decide between an
- * anchor and a text block. Never put a non-link reference in an `href`.
- */
-export interface ExternalShipment {
-    /** Carrier name as the sender reports it, e.g. `PostNL`, `Pallet`, `Ex works`. */
-    carrier: string;
-    /** A tracking URL, a carrier reference, or pickup instructions. */
-    reference: string;
-    /** True when `reference` is an http(s) URL safe to render as a link. */
-    isLink: boolean;
-    /** ISO-8601 dispatch timestamp, or null if the sender omitted it. */
-    shippedAt: string | null;
-    /** Which delivery of the order this parcel belongs to. */
-    deliveryNumber: string;
-}
-/**
- * Order minimums in effect on the active channel (inline order-constraints
- * plugin). Display/pre-validation only — checkout enforces server-side.
- */
-export interface ActiveChannelOrderConstraints {
-    /**
-     * Minimum vs the GROSS order total, minor units. Null when unset. This is the
-     * channel-wide minimum raised by any price-list minimum applying to the
-     * signed-in customer, so it varies per visitor.
-     */
-    minOrderAmountGross: number | null;
-    /**
-     * Minimum vs the NET (tax-exclusive) total, minor units, when a price list
-     * applying to this customer states its minimum ex tax. Independent of
-     * `minOrderAmountGross` — both bind, and neither can be derived from the
-     * other without a tax rate. Null when no net-basis minimum applies.
-     */
-    minOrderAmountNet: number | null;
-    /** Minimum total item count, from an applicable price list. Null when unset. */
-    minOrderQuantity: number | null;
-    /** Default fulfillment profile minimum vs the NET subtotal, minor units. Null when unset. */
-    fulfillmentMinOrderNet: number | null;
-    currencyCode: string;
-    /**
-     * True when the signed-in customer's group is exempt from the CHANNEL-wide
-     * minimum. A price-list minimum still applies, so `minOrderAmountGross` may
-     * be non-null while this is true.
-     */
-    customerIsExempt: boolean;
-}
-export interface ShippingMethod {
-    id: string;
-    name: string;
-    description: string;
-    price: number;
-    priceWithTax: number;
-    metadata?: Record<string, unknown>;
-    /** True when this is the signed-in customer's eligible Exact default. */
-    isPreferred: boolean;
-    /** False when the current externally governed customer cannot select this mapping. */
-    isDeliveryTermsEligible: boolean;
-}
-export interface PaymentMethod {
-    id: string;
-    name: string;
-    code: string;
-    description: string;
-    isEligible: boolean;
-    eligibilityMessage: string | null;
-}
-export interface Customer {
-    id: string;
-    firstName: string;
-    lastName: string;
-    emailAddress: string;
-    phoneNumber?: string;
-    addresses: CustomerAddress[];
-    orders?: {
-        items: OrderSummary[];
-        totalItems: number;
-    };
-    /**
-     * Customer groups the customer belongs to in the active channel. Drives
-     * B2B-only UI (navigation, VAT-mode default, order gating) — pricing is
-     * already applied server-side, so groups are for presentation only.
-     */
-    groups?: CustomerGroup[];
-    /**
-     * Whether this customer is a trade (B2B) account — i.e. belongs to one of the
-     * channel's configured B2B customer groups. The authoritative signal to gate
-     * B2B UI on, so a storefront never hard-codes a group name. Optional because
-     * a Vendure predating the field simply omits it.
-     *
-     * Presentation only: pricing, the tax display mode and access to quotes /
-     * credit / contract pricing are all resolved server-side regardless.
-     */
-    isB2B?: boolean;
-}
-/** A customer group, as exposed to the storefront (identity only). */
-export interface CustomerGroup {
-    id: string;
-    name: string;
-}
+    lines: PlacementRejectionLine[] | null;
+};
 /**
- * A price list applying to the active customer. Identity only — prices are
- * applied server-side; storefronts use this to label which lists (contract /
- * tier) the signed-in customer is on.
+ * A generated result with every list two selections merge typed as ONE list of
+ * the merged element. When a document selects a list twice — a fragment's
+ * `lines` and its own `lines { backorderedQuantity }`, or the `fulfillments` of
+ * two fragments — codegen prints it as `A[] & B[]`, and TypeScript types the
+ * callbacks of `.map`, `.filter` and `.find` on such a list with `A` alone, so
+ * the fields only `B` selected cannot be read there. GraphQL sends one list of
+ * merged elements; this says so. `getOrderByCode` and `getCustomerOrders`
+ * resolve to it.
  */
-export interface CustomerPriceList {
-    id: string;
-    name: string;
-    isContract: boolean;
-}
-export interface CustomerAddress {
-    id: string;
-    fullName: string;
-    streetLine1: string;
-    streetLine2?: string;
-    city: string;
-    province?: string;
-    postalCode: string;
-    country: {
-        code: string;
-        name: string;
-    };
-    defaultShippingAddress: boolean;
-    defaultBillingAddress: boolean;
-}
-export interface OrderSummary {
-    id: string;
-    code: string;
-    state: string;
-    /** Net (excl. tax) order total, in minor units. */
-    total: number;
-    totalWithTax: number;
-    currencyCode: string;
-    createdAt: string;
-    lines: Array<{
-        id: string;
-        quantity: number;
-        /**
-         * Units stock did not cover at placement (backorder); 0 otherwise.
-         * Selected by `getCustomerOrders`; `undefined` from `getCurrentCustomer`.
-         */
-        backorderedQuantity?: number;
-        /** Line total incl. tax, in minor units. */
-        linePriceWithTax: number;
-        productVariant: {
-            id: string;
-            name: string;
-            sku: string;
-            product: {
-                slug: string;
-                featuredAsset: {
-                    preview: string;
-                    presets?: {
-                        xs?: {
-                            webpUrl: string;
-                        };
-                    };
-                } | null;
-            };
-        };
-    }>;
-    fulfillments?: Fulfillment[] | null;
-    /** Tracking pushed by an external fulfilment system. See {@link ExternalShipment}. */
-    externalShipments?: ExternalShipment[] | null;
-    /** Immutable source-aware payment condition captured when this order was accepted. */
-    paymentTerms?: OrderPaymentTermsSnapshot | null;
-    /** Immutable delivery terms captured when this order was accepted. */
-    deliveryTerms?: OrderDeliveryTermsSnapshot | null;
-}
-/** An invoice issued for one of the signed-in customer's orders. */
-export interface CustomerInvoice {
-    id: string;
-    invoiceNumber: string;
-    /** Issue date (ISO-8601 date). */
-    invoicedOn: string;
-    /** Minor units. */
-    totalWithTax: number;
-    currencyCode: string;
-    languageCode: string;
-    createdAt: string;
-}
-/** Base64-encoded invoice PDF download. */
-export interface CustomerInvoicePdf {
-    base64: string;
-    filename: string;
-    invoiceNumber: string;
-}
+export type MergedSelection<T> = [T] extends [string | number | boolean | bigint | null | undefined] ? T : T extends ReadonlyArray<unknown> ? MergedSelection<T[number]>[] : T extends object ? {
+    [K in keyof T]: MergedSelection<T[K]>;
+} : T;
 /** A line that could not be re-added during a `reorder()` call. */
 export interface ReorderSkipped {
     variantId: string;
@@ -1310,8 +691,9 @@ export interface ReorderSkipped {
     errorCode: string;
     message: string;
 }
+/** What `reorder()` resolves to: the cart after the last line that could be added. */
 export interface ReorderResult {
-    order: Order;
+    order: Shop.OrderFragment;
     addedLines: number;
     skipped: ReorderSkipped[];
 }
@@ -1338,145 +720,15 @@ export type LoginResult = {
 } | {
     status: 'account_not_verified';
 };
-export interface CustomerInput {
-    firstName: string;
-    lastName: string;
-    emailAddress: string;
-    phoneNumber?: string;
-}
-export interface AddressInput {
-    fullName: string;
-    streetLine1: string;
-    streetLine2?: string;
-    city: string;
-    province?: string;
-    postalCode: string;
-    countryCode: string;
-    phoneNumber?: string;
-    company?: string;
-}
-export interface PaymentInput {
-    method: string;
-    metadata?: Record<string, unknown>;
-}
+/** A Stripe PaymentIntent for the active order: hand `clientSecret` to Stripe.js. */
 export interface StripePaymentIntentResult {
     clientSecret: string;
 }
-export interface MolliePaymentMethodsInput {
-    paymentMethodCode: string;
-}
-export interface MolliePaymentMethodAmount {
-    value: number;
-    currency: string;
-}
-export interface MolliePaymentMethod {
-    id: string;
-    code: string;
-    description: string;
-    minimumAmount: MolliePaymentMethodAmount;
-    maximumAmount: MolliePaymentMethodAmount | null;
-    image: {
-        size1x: string;
-        size2x: string;
-        svg: string;
-    };
-    /**
-     * Mollie's availability status for this method on the order (e.g.
-     * `"activated"`, `"pending-boarding"`). `null` when Mollie omits it.
-     */
-    status: string | null;
-}
-/**
- * A storefront-visible Mollie payment method, ordered per the channel's saved
- * configuration with hidden methods removed. Returned by
- * `commerce.getOrderedMolliePaymentMethods`. Decoupled from
- * {@link MolliePaymentMethod}: this is the curated, channel-ordered shape from
- * the platform's `payment-config` plugin, not the raw community plugin type.
- */
-export interface OrderedMollieMethod {
-    id: string;
-    /** Mollie method id (e.g. `"ideal"`); pass as `molliePaymentMethodCode`. */
-    code: string;
-    description: string | null;
-    /** Mollie's icon URL (SVG preferred, 2x PNG fallback); null when omitted. */
-    imageUrl: string | null;
-    /**
-     * Mollie's availability status for this method (e.g. `"activated"`). `null`
-     * when Mollie omits it.
-     */
-    status: string | null;
-}
-export interface CreateMolliePaymentIntentInput {
-    paymentMethodCode: string;
-    redirectUrl?: string;
-    molliePaymentMethodCode?: string;
-    locale?: string;
-    immediateCapture?: boolean;
-    /**
-     * Create the intent for a specific order rather than the session's active
-     * order — required when topping up an order in `ArrangingAdditionalPayment`,
-     * or when driving checkout for a non-active order.
-     */
-    orderId?: string;
-}
+/** A Mollie hosted checkout for the order: redirect the shopper to `url`. */
 export interface MolliePaymentIntentResult {
     url: string;
 }
-/**
- * Minimal order shape returned by `syncMolliePaymentStatus`. Use the `state`
- * to confirm the order settled (e.g. `PaymentSettled`) after a delayed/missing
- * Mollie webhook. `null` when no order matches the code.
- */
-export interface MollieOrderStatusResult {
-    id: string;
-    code: string;
-    state: string;
-}
-export interface RegisterInput {
-    firstName: string;
-    lastName: string;
-    emailAddress: string;
-    password: string;
-    phoneNumber?: string;
-}
-export interface UpdateCustomerInput {
-    title?: string;
-    firstName: string;
-    lastName: string;
-    phoneNumber?: string;
-}
-export interface UpdateAddressInput {
-    id: string;
-    fullName?: string;
-    streetLine1?: string;
-    streetLine2?: string;
-    city?: string;
-    province?: string;
-    postalCode?: string;
-    countryCode?: string;
-    phoneNumber?: string;
-    company?: string;
-    defaultShippingAddress?: boolean;
-    defaultBillingAddress?: boolean;
-}
-export interface Country {
-    id: string;
-    code: string;
-    name: string;
-}
-export interface ActiveChannel {
-    id: string;
-    code: string;
-    defaultLanguageCode: string;
-    availableLanguageCodes: string[];
-    defaultCurrencyCode: string;
-    availableCurrencyCodes: string[];
-    customFields: ChannelCustomFields;
-}
-export interface FacetValueFilterInput {
-    and?: string;
-    or?: string[];
-}
+export type { FacetValueFilterInput } from './generated/shop.js';
 export interface SearchInput {
     term: string;
     collectionSlug?: string;
@@ -1491,7 +743,7 @@ export interface SearchInput {
     /** Filter to products belonging to ALL of these collection ids (AND). */
     collectionIds?: string[];
     facetValueIds?: string[];
-    facetValueFilters?: FacetValueFilterInput[];
+    facetValueFilters?: Shop.FacetValueFilterInput[];
     take?: number;
     skip?: number;
     sort?: {
@@ -1510,92 +762,13 @@ export interface SearchInput {
      *
      * **Until the channel has had a full reindex**, documents written before this
      * attribute existed carry no state at all: they match `['none']` and nothing
-     * else, and their `SearchResult.availability` reads `null`. So a "coming
-     * soon" or "pre-order" filter can legitimately come back empty on a channel
-     * that has the products but not the index.
+     * else, and their `SearchResultItemFragment.availability` reads `null`. So a
+     * "coming soon" or "pre-order" filter can legitimately come back empty on a
+     * channel that has the products but not the index.
      */
     availability?: ProductAvailabilityState[];
 }
-export interface SearchResultItem {
-    productId: string;
-    /**
-     * Orderable variant id for this search row — pass THIS (never `productId`) to
-     * `addToCart`. Under `groupByProduct` it is a representative variant; for the
-     * exact variant on multi-variant products, load `getProduct(slug)`.
-     */
-    productVariantId: string;
-    productName: string;
-    slug: string;
-    description: string;
-    price: {
-        value?: number;
-        min?: number;
-        max?: number;
-    };
-    priceWithTax: {
-        value?: number;
-        min?: number;
-        max?: number;
-    };
-    currencyCode: string;
-    productAsset: {
-        preview: string;
-        focalPoint?: {
-            x: number;
-            y: number;
-        };
-    } | null;
-    collectionIds: string[];
-    /** Aggregate availability across all stock locations (Meilisearch plugin). */
-    inStock: boolean;
-    /**
-     * The merchant's publication state for this row's variant, resolved against
-     * the moment of the request.
-     *
-     * **Nullable, unlike `ProductVariant.availability`** — a search hit is an
-     * indexed document, and one written before this attribute existed genuinely
-     * does not know the state. `null` says exactly that; it is NOT `'none'`. A
-     * full reindex is what removes it. Render a `null` row exactly as you would
-     * have before pre-orders existed.
-     *
-     * `inStock` is unchanged and independent: a pre-orderable variant with no
-     * stock is `inStock: false` with `state: 'preorder'`, and a storefront that
-     * wants "buyable now, or pre-orderable" combines the two.
-     */
-    availability: ProductAvailability | null;
-}
-export interface SearchFacetValue {
-    facetValue: {
-        id: string;
-        name: string;
-        code?: string;
-        facet: {
-            id: string;
-            name: string;
-            code?: string;
-        };
-    };
-    count: number;
-}
-export interface SearchResult {
-    items: SearchResultItem[];
-    totalItems: number;
-    facetValues: SearchFacetValue[];
-}
-/** `eq` boolean operator mirroring Vendure's `BooleanOperators` input. */
-export interface BooleanOperators {
-    eq?: boolean;
-}
-/**
- * Subset of Vendure's `ProductFilterParameter` the SDK types explicitly.
- * `enabled` is the field `getProducts` defaults on; the index signature keeps
- * the parameter open to the other server-side filter fields without the SDK
- * having to enumerate them all.
- */
-export interface ProductFilterParameter {
-    enabled?: BooleanOperators;
-    [field: string]: unknown;
-}
+export type { BooleanOperators, ProductFilterParameter } from './generated/shop.js';
 export interface ProductListOptions {
     take?: number;
     skip?: number;
@@ -1625,9 +798,9 @@ export interface ProductListOptions {
      * Ignored on the deprecated `{ collectionSlug }` path, which reroutes to the
      * search backend and returns its own already-flat row shape regardless.
      *
-     * Both shapes are typed `ProductSummary`; the omitted members are optional on
-     * that type, so a card row is a valid — just sparser — `ProductSummary`. Read
-     * a dropped field and you get `undefined`, not a stale value.
+     * A `'card'` row is typed {@link ProductCardFragment}, the full row
+     * {@link ProductSummaryFragment}; `getProducts` picks the type from this
+     * option when it is a literal.
      */
     detail?: 'card' | 'full';
     /**
@@ -1635,7 +808,9 @@ export interface ProductListOptions {
      * option silently reroutes the call through the search backend, whose rows
      * are flatter than the products list (single synthesised variant, no `sku`,
      * `facetValues`, or `collections`) — the named method makes that shape
-     * explicit. The option keeps working for now.
+     * explicit. The option keeps working for now; a non-empty slug returns
+     * {@link CollectionProductSummary} rows, so the call types as
+     * {@link ProductListPage}.
      */
     collectionSlug?: string;
     /**
@@ -1655,7 +830,7 @@ export interface ProductListOptions {
      * the Shop API additionally forces `enabled: { eq: true }` server-side, so
      * no filter can surface disabled products.
      */
-    filter?: ProductFilterParameter;
+    filter?: Shop.ProductFilterParameter;
     /**
      * @deprecated The Shop API forces `enabled: { eq: true }` server-side, so
      * `enabled: false` cannot surface disabled products; the shorthand is
@@ -1677,10 +852,9 @@ export interface CollectionProductListOptions {
  * A product card row from the search backend, as returned by
  * `getProductsInCollection`. Honest projection of a search hit: exactly one
  * synthesised variant, and none of the fields the search index does not carry
- * (`sku`, `facetValues`, `collections`). Structurally a subset of
- * `ProductSummary`, so card components consuming `{ featuredAsset,
- * variants[0] }` work with either. Load `getProduct(slug)` for the full
- * variant/asset tree.
+ * (`sku`, `facetValues`, `collections`). Card components consuming
+ * `{ featuredAsset, variants[0] }` work with this and the list rows alike.
+ * Load `getProduct(slug)` for the full variant/asset tree.
  */
 export interface CollectionProductSummary {
     id: string;
@@ -1709,12 +883,12 @@ export interface CollectionProductVariant {
     stockLevel: 'IN_STOCK' | 'OUT_OF_STOCK';
     /**
      * The merchant's publication state for this row, carried through from the
-     * search hit — so it is `null` on the same terms `SearchResultItem`
+     * search hit — so it is `null` on the same terms `SearchResultItemFragment`
      * describes: a document written before the attribute existed does not know,
      * and only a full reindex fixes that. Not `'none'`; render `null` exactly as
      * you would have before pre-orders existed.
      */
-    availability: ProductAvailability | null;
+    availability: Shop.ProductAvailabilityFragment | null;
 }
 export interface CollectionListOptions {
     take?: number;
@@ -1724,180 +898,21 @@ export interface OrderListOptions {
     take?: number;
     skip?: number;
 }
-export interface FavoriteVariant {
-    id: string;
-    name: string;
-    sku: string;
-    price: number;
-    priceWithTax: number;
-    currencyCode: string;
-    stockLevel: string;
-    /** ATP numbers — `null` when the channel does not expose operational stock. */
-    stockOnHand: number | null;
-    stockAllocated: number | null;
-    saleable: number | null;
-    /**
-     * Incoming-stock numbers — additionally `null` unless the signed-in customer's
-     * group may see incoming stock. `nextExpectedArrival` is the earliest FUTURE
-     * arrival (ISO 8601, never past) and is `null` when every open line is overdue,
-     * even while `incomingStock > 0`.
-     */
-    incomingStock: number | null;
-    projectedSaleable: number | null;
-    nextExpectedArrival: string | null;
-    /**
-     * Units BEYOND `saleable` the signed-in customer may order on backorder right
-     * now. The quantity ceiling is `max(0, saleable) + backorderAllowance` (see
-     * `maxOrderableQuantity` in `@sixtyninecommerce/client/pricing`). `null` when
-     * the question does not apply — anonymous, group may not backorder, or the
-     * channel hides stock — treat exactly like today; `0` = denied; a large
-     * value (2,000,000,000) is the "unlimited" sentinel. A snapshot: the server
-     * re-checks on add-to-cart and at placement and refuses with the usual
-     * `InsufficientStockError` / `INSUFFICIENT_STOCK`, whose `quantityAvailable`
-     * then already includes the allowance.
-     */
-    backorderAllowance: number | null;
-    priceListName: string | null;
-    retailPrice: number | null;
-    retailPriceWithTax: number | null;
-    /** Tax rate applied to this price in the active channel/zone, e.g. `{ value: 21 }` for 21% VAT. */
-    taxRateApplied: {
-        value: number;
-    } | null;
-    priceTiers: PriceTier[] | null;
-    /**
-     * The merchant's publication state in force for this variant, resolved
-     * against the moment of the request — same field, same rules as
-     * `ProductVariant.availability`. A favourites list is where a coming-soon or
-     * pre-order label matters most: the buyer saved it precisely because they
-     * could not have it yet.
-     */
-    availability: ProductAvailability;
-    availabilityByLocation: VariantLocationAvailability[];
-    product: {
-        id: string;
-        name: string;
-        slug: string;
-        featuredAsset: Asset | null;
-    };
-    options: Array<{
-        id: string;
-        name: string;
-        group: {
-            name: string;
-        };
-    }>;
-    customFields: {
-        minOrderQuantity: number | null;
-        salesUnit: number | null;
-        position: number | null;
-    };
-}
-export interface FavoriteItem {
-    id: string;
-    productVariantId: string;
-    createdAt: string;
-    productVariant: FavoriteVariant | null;
-}
-export interface SavedListItem {
-    id: string;
-    productVariantId: string;
-    quantity: number;
-    position: number;
-    createdAt: string;
-    productVariant: ProductVariant | null;
-}
-export interface SavedList {
-    id: string;
-    name: string;
-    items: SavedListItem[];
-    createdAt: string;
-    updatedAt: string;
-}
+/** A "back in stock" subscription, as `subscribeToStockNotification` returns it. */
 export interface StockNotificationSubscriptionResult {
     id: string;
     productVariantId: string;
     emailAddress: string;
     createdAt: string;
 }
+/** One page of `getProducts`, whichever of its three row shapes the options chose. */
+export type ProductListPage = PaginatedList<Shop.ProductSummaryFragment> | PaginatedList<Shop.ProductCardFragment> | PaginatedList<CollectionProductSummary>;
 export interface PaginatedList<T> {
     items: T[];
     totalItems: number;
 }
-/**
- * One locale's slug override for a CMS collection item, as the CMS emits it.
- *
- * NOT a bare string: both `GET /resolve` and the single-item endpoints build
- * this map from `CollectionItemsService.getSlugTranslations`, which returns
- * `{ slug, path }` per language. It was declared here as `Record<string, string>`,
- * so `slug_translations[locale].replace(...)` — what the SEO chain did — threw
- * `translated.replace is not a function` on every translated CMS page.
- */
-export interface SlugTranslation {
-    /** The locale's slug SEGMENT — `over-ons`, never a full path. */
-    slug: string;
-    /**
-     * Channel-relative, locale-UNPREFIXED path for this locale (`/over-ons`), or
-     * `null` when the item has no addressable path at all (its collection has no
-     * `basePath`). The column is nullable, so a consumer must handle `null`; the
-     * locale prefix is applied downstream from channel config, never stored here.
-     */
-    path: string | null;
-}
-export interface ResolvedContent {
-    item?: Record<string, unknown>;
-    /** Resolved field values keyed by field slug (locale-filtered). */
-    values?: Record<string, unknown>;
-    collection?: {
-        id: string;
-        name: string;
-        slug: string;
-        basePath?: string | null;
-        isSingleton?: boolean;
-        titleFieldSlug?: string | null;
-        [key: string]: unknown;
-    };
-    /**
-     * Ancestor chain, root first, seeded with the item itself — so a path that
-     * resolves always carries at least one entry. Carries no `title`: the CMS's
-     * recursive ancestor walk selects `id`, `slug` and `path` only
-     * (`ResolveService.getBreadcrumbs`). This was declared
-     * `Array<{ title: string; path: string }>`, which named a field the platform
-     * has never emitted.
-     */
-    breadcrumbs?: Array<{
-        id: string;
-        slug: string;
-        path: string | null;
-    }>;
-    /** Per-locale slug overrides, keyed by language code. See {@link SlugTranslation}. */
-    slug_translations?: Record<string, SlugTranslation>;
-    /**
-     * Derived SEO metadata block (from the standard SEO field group). `null` when
-     * the item/page carries no SEO fields. Feed to `parseCmsItemMetadata`.
-     */
-    metadata?: Record<string, unknown> | null;
-}
-export interface SitemapEntry {
-    id: string;
-    path: string;
-    title: string | null;
-    collection_slug: string | null;
-    updated_at: string;
-    /** Present only for collection landing pages (basePath routes). */
-    type?: 'collection_page';
-    /** Present only when the request specified a language_code. */
-    language_code?: string;
-}
-export interface ContentItemSummary {
-    id: string;
-    slug: string | null;
-    status: string;
-    collection_id: string;
-    collection_name: string;
-    collection_title_field_slug: string | null;
-    title: string | null;
-}
+export type { PublicAssetDto, PublicAssetPresetsDto, PublicAssetPresetUrlsDto, PublicAssetTranslationDto, PublicBreadcrumbDto, PublicChannelDto, PublicCollectionDetailDto, PublicCollectionDto, PublicCollectionFieldDto, PublicCollectionItemDetailDto, PublicCollectionItemDto, PublicCollectionItemSearchResultDto, PublicCollectionPageValuesDto, PublicContentStringDto, PublicContentStringListResponseDto, PublicContentStringValueDto, PublicFormDto, PublicFormFieldConstraintDto, PublicFormFieldDto, PublicFormFieldTypeDto, PublicFormListResponseDto, PublicFormSlugRuleDto, PublicFormSlugRulesDto, PublicFormTranslationDto, PublicItemSummaryDto, PublicItemWithFieldsDto, PublicMenuDetailDto, PublicMenuSummaryDto, PublicPaginationTotalDto, PublicResolvedCollectionDto, PublicResolvedContentDto, PublicResolvedFieldDto, PublicResolvedItemDto, PublicResolvedSubFieldDto, PublicSeoMetadataDto, PublicSitemapEntryDto, PublicSitemapSeoDto, PublicVendureAssetDescriptionDto, } from './generated/cms.js';
+export type { PublicCapabilitiesDto, PublicCapabilityManifestDto, PublicCapabilityReadinessDto, PublicRouteEntryDto, PublicRoutesMetadataDto, PublicRoutesResponseDto, } from './generated/plugins.js';
 /**
  * Channel-wide CMS search query. All fields optional — supplying only `q`
  * searches across every collection in the store. Use `collectionId` or
@@ -1915,94 +930,13 @@ export interface ContentSearchQuery {
     languageCode?: string;
 }
 /**
- * A single CMS content item search hit. Field values are flattened on the
- * document with locale-suffixed keys (`title_en`, `title_nl`, ...) — index
- * with `[fieldSlug]` or `[fieldSlug + '_' + languageCode]` as needed.
+ * One page of `content.getCollectionItems`: the items (field values
+ * locale-merged when a `languageCode` was requested, asset references
+ * resolved) and the total across every page.
  */
-export interface ContentSearchHit {
-    id: string;
-    channel_id: string;
-    collection_id: string;
-    collection_slug: string;
-    slug: string | null;
-    path: string | null;
-    parent_id: string | null;
-    position: number;
-    status: string;
-    created_at: number;
-    updated_at: number;
-    published_at: number | null;
-    [fieldSlug: string]: unknown;
-}
-export interface ContentSearchResult {
-    hits: ContentSearchHit[];
-    total: number;
-    limit: number;
-    offset: number;
-    processing_time_ms: number;
-}
-export interface ContentItemWithFields {
-    id: string;
-    title: string | null;
-    fieldValues: Record<string, unknown>;
-}
-export interface CollectionFieldDefinition {
-    id: string;
-    slug: string;
-    label: string;
-    fieldType: string;
-    position: number;
-    isRequired: boolean;
-    isLocalizable: boolean;
-    config: Record<string, unknown> | null;
-}
-export interface CollectionPageValues {
-    fields: CollectionFieldDefinition[];
-    values: Record<string, unknown>;
-}
-/** A CMS collection (content type) as returned by `GET /collections`. */
-export interface CmsCollection {
-    id: string;
-    name: string;
-    slug: string;
-    description: string | null;
-    isSingleton: boolean;
-    basePath: string | null;
-    isHierarchical: boolean;
-    titleFieldSlug: string | null;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface CmsCollectionDetail extends CmsCollection {
-    fields: CollectionFieldDefinition[];
-}
-/**
- * A collection item from the direct CMS item endpoints. `values` holds the
- * item's field values keyed by field slug, locale-merged when a
- * `languageCode` was requested. Public callers only ever see published items.
- */
-export interface CmsCollectionItem {
-    id: string;
-    collectionId: string;
-    slug: string | null;
-    status: 'draft' | 'published' | 'archived';
-    parentId: string | null;
-    publishedAt: string | null;
-    createdAt: string;
-    updatedAt: string;
-    values: Record<string, unknown>;
-    /**
-     * Per-language slug overrides, keyed by language code. Present on single-item
-     * reads, filled from the same `getSlugTranslations` helper `GET /resolve`
-     * uses — hence the same object-per-locale shape. See {@link SlugTranslation}.
-     */
-    slug_translations?: Record<string, SlugTranslation>;
-    /** Forward-compat: additional entity fields the CMS may add. */
-    [key: string]: unknown;
-}
 export interface CmsCollectionItemList {
-    items: CmsCollectionItem[];
-    total: number;
+    items: Cms.PublicCollectionItemDto[];
+    total: Cms.PublicPaginationTotalDto['total'];
 }
 export interface CollectionItemsQuery {
     /** Filter by parent item; pass `'root'` for top-level items. */
@@ -2024,63 +958,15 @@ export interface ContentQueryOptions {
     sort?: string;
     languageCode?: string;
 }
-export interface FormField {
-    slug: string;
-    label: string;
-    type: string;
-    required: boolean;
-    /** Presentational config (e.g. select option labels). */
-    config: Record<string, unknown>;
-    /**
-     * Effective per-field validation constraints the server enforces on submit
-     * (min/max length, numeric range, options, pattern), resolved from the
-     * field's `validation` first and `config` as a fallback. Contains only
-     * recognized constraint keys. Mirror it to validate client-side. See
-     * {@link FormFieldTypeDescriptor} / `content.getFormFieldTypes()`.
-     */
-    validation: Record<string, unknown>;
-    position: number;
-}
-/** A form-level translation as emitted by the public projection. */
-export interface FormTranslation {
-    languageCode: string;
-    title: string;
-    description: string | null;
-    submitButtonText: string | null;
-    successMessage: string | null;
-}
-export interface FormDefinition {
-    id: string;
-    name: string;
-    slug: string;
-    /** Where the storefront should send the visitor after a successful submit. */
-    redirectUrlOnSuccess: string | null;
-    /** True when the form has internal-notification recipients configured (addresses are never exposed). */
-    hasNotifications: boolean;
-    /** True when a visitor confirmation email will be sent on submit. */
-    sendsConfirmation: boolean;
-    fields: FormField[];
-    translations: FormTranslation[];
+/**
+ * `content.getForm` / `getFormBySlug`: the public form, plus where and how to
+ * submit it (the SDK adds `submitUrl`, `submitMethod` and `submitHeaders`).
+ */
+export type FormDefinition = Cms.PublicFormDto & {
     submitUrl: string;
     submitMethod: string;
     submitHeaders: Record<string, string>;
-}
-/**
- * A form as returned by `content.listForms()`. Mirrors the public projection.
- * NOTE: list responses populate id/name/slug/redirect + the email booleans;
- * `fields` and `translations` arrive EMPTY in list context — fetch a single
- * form via `getForm`/`getFormBySlug` to load them.
- */
-export interface FormSummary {
-    id: string;
-    name: string;
-    slug: string;
-    redirectUrlOnSuccess: string | null;
-    hasNotifications: boolean;
-    sendsConfirmation: boolean;
-    fields: FormField[];
-    translations: FormTranslation[];
-}
+};
 export interface FormListOptions {
     limit?: number;
     offset?: number;
@@ -2091,55 +977,10 @@ export interface FormListOptions {
     /** Locale for the projected field labels. Defaults to the client language. */
     locale?: string;
 }
-export interface FormListResult {
-    data: FormSummary[];
-    pagination: {
-        total: number;
-    };
-}
-/** One constraint key a field type honors (see {@link FormFieldTypeDescriptor}). */
-export interface FormFieldTypeConstraint {
-    key: string;
-    valueType: 'integer' | 'number' | 'string' | 'string[]';
-    description: string;
-}
-/**
- * Describes a form field type and the config/validation constraints it honors.
- * The SDK ships a static mirror as {@link FORM_FIELD_TYPES}; the same data is
- * served live by `content.getFormFieldTypes()` (GET /forms/field-types).
- */
-export interface FormFieldTypeDescriptor {
-    type: string;
-    label: string;
-    description: string;
-    /** Shape of the value a submission sends for this field. */
-    valueType: string;
-    /** Constraint keys honored on submit; resolved from `validation` first, then `config`. */
-    constraints: FormFieldTypeConstraint[];
-    notes?: string;
-}
-/** The slug shape one authoring surface enforces (form slug or field slug). */
-export interface FormSlugRule {
-    /** Source of the regex the CMS validates against. */
-    pattern: string;
-    maxLength: number;
-    description: string;
-    validExamples: string[];
-    invalidExamples: string[];
-}
-/**
- * Slug rules for form authoring: form slugs are HYPHEN-separated, field slugs
- * are UNDERSCORE-separated. Shipped statically as {@link FORM_SLUG_RULES} and
- * served live in the field-types registry response.
- */
-export interface FormSlugRules {
-    form: FormSlugRule;
-    field: FormSlugRule;
-}
 /** Everything GET /forms/field-types carries: the field types plus the slug rules. */
 export interface FormFieldTypeRegistry {
-    fieldTypes: FormFieldTypeDescriptor[];
-    slugRules: FormSlugRules;
+    fieldTypes: Cms.PublicFormFieldTypeDto[];
+    slugRules: Cms.PublicFormSlugRulesDto;
 }
 /**
  * Result of `submitForm` — discriminate on `success`. Field-validation
@@ -2163,88 +1004,36 @@ export type FormSubmissionResult = {
         message: string;
     }>;
 };
-export interface ContentStrings {
-    [key: string]: Record<string, string>;
-}
-export interface MenuItem {
-    id: string;
-    parentId: string | null;
-    itemType: string;
-    url: string | null;
-    targetId: string | null;
-    position: number;
-    openInNewTab: boolean;
-    metadata: Record<string, unknown> | null;
-    translations: Array<{
-        languageCode: string;
-        label: string;
-        title: string | null;
-    }>;
-    resolvedPath?: string;
-    children: MenuItem[];
-}
-export interface Menu {
-    id: string;
-    name: string;
-    slug: string;
-    items?: MenuItem[];
-}
-export interface RouteEntry {
-    path: string;
-    type: 'cms' | 'collection' | 'product';
-    id: string;
-    title: string;
-    slug?: string;
-    updated_at?: string;
-    source?: string;
-    /**
-     * Only set on `product` routes. A product listed under multiple collections
-     * emits one route per collection; exactly one — the canonical URL home — is
-     * `true`, the rest `false`. Filter to `canonical !== false` to get the
-     * deduplicated (one-per-product) URL set. `undefined` on `cms`/`collection`
-     * routes, which are already one-per-entity.
-     */
-    canonical?: boolean;
-}
+/**
+ * `content.getContentStrings('export')`: every content string of the channel,
+ * `key → language code → value`.
+ */
+export type ContentStrings = Cms.paths['/content-strings/export']['get']['responses'][200]['content']['application/json'];
+/**
+ * One node of the tree `content.getMenu` builds from the menu's flat items:
+ * the item's own members (camelCase or legacy snake_case on the wire, read
+ * either way), its translations, and its children ordered by `position`.
+ */
+export type MenuItem = Pick<Cms.PublicMenuItemDto, 'id' | 'parentId' | 'itemType' | 'url' | 'targetId' | 'position' | 'openInNewTab' | 'metadata' | 'resolvedPath'> & {
+    translations: Array<Pick<Cms.PublicMenuItemTranslationDto, 'languageCode' | 'label' | 'title'>>;
+    children: MenuItem[];
+};
+/**
+ * `content.getMenu`: the menu, its flat `items` replaced by the tree of
+ * {@link MenuItem}s. `content.getMenus` returns {@link PublicMenuSummaryDto}s.
+ */
+export type Menu = Omit<Cms.PublicMenuDetailDto, 'items'> & {
+    items: MenuItem[];
+};
 /**
  * A manifest entry as `findRoute` returns it, plus the cache tags the page's
  * reads should carry — `product:<id>` / `collection:<id>`, none for CMS pages.
  * Load the page by `id` (`getProductById`, `getCollectionById`,
  * `getProductsInCollectionById`) and those tags are already on its reads.
  */
-export interface ResolvedRoute extends RouteEntry {
+export type ResolvedRoute = Plugins.PublicRouteEntryDto & {
     readonly cacheTags: readonly string[];
-}
-export interface RoutesMetadata {
-    default_language: string;
-    available_languages: string[];
-    generated_at: string;
-}
-export interface RoutesResponse {
-    data: Record<string, RouteEntry[]>;
-    metadata: RoutesMetadata;
-}
-export interface ExchangeRate {
-    baseCurrency: string;
-    targetCurrency: string;
-    rate: string;
-    inverseRate: string;
-    rateDate: string;
-}
-export interface ConvertedAmount {
-    originalAmount: string;
-    originalCurrency: string;
-    convertedAmount: string;
-    targetCurrency: string;
-    rate: string;
-    rateDate: string;
-}
-/** One entry of a `convertToMultiple()` result. */
-export interface BulkConversionResult {
-    currency: string;
-    amount: string;
-    rate: string;
-}
+};
 export interface PriceDisplay {
     price: number;
     priceWithTax: number;
@@ -2256,7 +1045,7 @@ export interface PriceDisplay {
     taxRate: number | null;
     hasDiscount: boolean;
     discountPercentage: number | null;
-    activeTier: PriceTier | null;
+    activeTier: Shop.PriceTierFragment | null;
 }
 export interface TierTableEntry {
     minQuantity: number;
@@ -2336,7 +1125,7 @@ export interface VariantPriceData {
     taxRateApplied?: {
         value: number;
     } | null;
-    priceTiers?: PriceTier[] | null;
+    priceTiers?: Shop.PriceTierFragment[] | null;
 }
 export interface OrderValidationResult {
     valid: boolean;
@@ -2348,73 +1137,6 @@ export interface OrderValidationError {
     required: number;
     actual: number;
 }
-export interface PropertyGroupTranslation {
-    id: string;
-    languageCode: string;
-    name: string;
-}
-export interface PropertyTranslation {
-    id: string;
-    languageCode: string;
-    name: string;
-    helpText: string | null;
-}
-export interface PropertyFieldFacet {
-    fieldSlug: string;
-    fieldType: string;
-    facetId: string;
-}
-export interface PropertyConfig {
-    options?: Array<{
-        value: string;
-        label: string;
-    }>;
-    min?: number;
-    max?: number;
-    maxLength?: number;
-    allowedCollectionIds?: string[];
-    filterableFieldSlugs?: string[];
-    /**
-     * For `product` field type: strict filter applied in the admin UI to
-     * narrow the picker. Storefront callers can ignore this — the selected
-     * product IDs are already stored in `PropertyValue.value` (as `string[]`).
-     */
-    productFilter?: {
-        filters?: Array<{
-            property_slug: string;
-            facet_value_ids: string[];
-        }>;
-        collection_id?: string | null;
-    };
-}
-export interface Property {
-    id: string;
-    slug: string;
-    fieldType: string;
-    isFilterable: boolean;
-    isRequired: boolean;
-    position: number;
-    config: PropertyConfig | null;
-    facetId: string | null;
-    fieldFacets: PropertyFieldFacet[];
-    translations: PropertyTranslation[];
-}
-export interface PropertyGroup {
-    id: string;
-    position: number;
-    translations: PropertyGroupTranslation[];
-    properties: Property[];
-}
-export interface PropertyValue {
-    id: string;
-    propertyId: string;
-    languageCode: string | null;
-    value: unknown;
-}
-export interface ProductPropertyGroupValues {
-    group: PropertyGroup;
-    values: PropertyValue[];
-}
 /**
  * A product's property values flattened to a `slug → value` record (the shape
  * a product-detail view actually renders). Produced by
@@ -2437,637 +1159,77 @@ export interface ResponsiveImageData {
     width: number;
     height: number;
 }
-export interface ReviewAttribute {
-    id: string;
-    slug: string;
-    label: string;
-    inputType: 'rating' | 'selection';
-    options: string[] | null;
-    isRequired: boolean;
-    section: 'product' | 'demographic';
-}
-export interface ProductReview {
-    id: string;
-    rating: number | null;
-    title: string | null;
-    body: string | null;
-    variantId: string | null;
-    customerDisplayName: string | null;
-    isVerifiedPurchase: boolean;
-    isEdited: boolean;
-    attributeValues: Record<string, number | string> | null;
-    imageAssetIds: string[] | null;
-    videoAssetIds: string[] | null;
-    helpfulCount: number;
-    notHelpfulCount: number;
-    merchantReply: string | null;
-    merchantReplyAt: string | null;
-    myVote: boolean | null;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface ReviewRatingDistribution {
-    one: number;
-    two: number;
-    three: number;
-    four: number;
-    five: number;
-}
-export interface ReviewRatingSummary {
-    averageRating: number | null;
-    reviewCount: number;
-    ratingCount: number;
-    distribution: ReviewRatingDistribution;
-}
-export interface ReviewAttributeAggregation {
-    attributeId: string;
-    label: string;
-    inputType: string;
-    averageRating: number | null;
-    distribution: Record<string, number> | null;
-}
-export interface ReviewChannelConfig {
-    reviewsEnabled: boolean;
-    reviewsRequireText: boolean;
-    reviewsAllowMedia: boolean;
-    reviewsAllowVoting: boolean;
-    reviewsAllowRating: boolean;
-    reviewMinBodyLength: number;
-    reviewMaxTitleLength: number;
-    reviewMaxImages: number;
-    reviewMaxVideos: number;
-}
-export interface CreateReviewInput {
-    productId: string;
-    variantId?: string;
-    rating?: number;
-    title?: string;
-    body?: string;
-    imageAssetIds?: string[];
-    videoAssetIds?: string[];
-    attributeValues?: Record<string, number | string>;
-}
-export interface UpdateReviewInput {
-    rating?: number;
-    title?: string;
-    body?: string;
-    imageAssetIds?: string[];
-    videoAssetIds?: string[];
-    attributeValues?: Record<string, number | string>;
-}
-export interface ReviewListOptions {
-    take?: number;
-    cursor?: string;
-    sort?: 'NEWEST' | 'OLDEST' | 'HIGHEST_RATING' | 'LOWEST_RATING' | 'MOST_HELPFUL';
-    rating?: number;
-}
-export interface RecentReviewsOptions {
-    limit?: number;
-    minRating?: number;
-    languageCode?: string;
-}
-export interface CreateReviewResult {
-    review: ProductReview;
-    requiresModeration: boolean;
-}
-export interface ReviewMediaUploadResult {
-    id: string;
-    preview: string;
-    mimeType: string;
-}
-export type CustomerSubscriptionStatus = 'incomplete' | 'trial' | 'active' | 'paused' | 'past_due' | 'cancelled' | 'expired' | 'completed' | 'INCOMPLETE' | 'TRIAL' | 'ACTIVE' | 'PAUSED' | 'PAST_DUE' | 'CANCELLED' | 'EXPIRED' | 'COMPLETED';
-export type SubscriptionFirstChargeTiming = 'immediate' | 'after_interval';
+/** A subscription change a shopper can ask for. */
 export type SubscriptionLifecycleAction = 'pause' | 'resume' | 'skip' | 'reschedule' | 'cancel' | 'undoCancellation';
-export interface SubscriptionProduct {
-    variantId: string;
-    quantity: number;
-    name: string;
-    sku: string;
-}
-export interface SubscriptionAllowedAction {
-    action: string;
-    allowed: boolean;
-    reason: string | null;
-}
-export interface SubscriptionUpcomingPayment {
-    dueAt: string | null;
-    amount: number;
-    currencyCode: string;
-    /**
-     * The outstanding cycle's payment state (`ready`, `processing`, `pending`,
-     * `action_required`, `unknown`, `failed`, or `charged_back` — a paid cycle the
-     * bank reversed), else a live checkout's state, else `scheduled`, `paused` or
-     * `none`. `failed` and `charged_back` are recovered with
-     * `recoverMySubscriptionPayment`.
-     */
-    state: string;
-    nextRetryAt: string | null;
-    checkoutUrl: string | null;
-}
-export interface SubscriptionPurchasePreview {
-    planId: string;
-    planName: string;
-    /**
-     * What the customer is charged per cycle, in minor units: products, shipping and
-     * the tax of their zone included. Pass it back as `expectedAmount` when starting.
-     */
-    amount: number;
-    /**
-     * Whether plan prices on this channel include tax. When false the plan price is
-     * net and `amount` adds the customer's VAT (none under reverse charge).
-     */
-    pricesIncludeTax: boolean;
-    /** `amount` without tax. */
-    netAmount: number;
-    /** The tax in `amount` for the customer's tax zone. */
-    taxAmount: number;
-    currencyCode: string;
-    firstPaymentAt: string;
-    firstChargeTiming: SubscriptionFirstChargeTiming;
-    billingInterval: string;
-    billingIntervalCount: number;
-    trialDays: number;
-    trialEndsAt: string | null;
-    minCycles: number | null;
-    maxCycles: number | null;
-    customerChangeCutoffHours: number;
-    cutoffAt: string | null;
-    mandateVerificationAmount: number;
-    products: SubscriptionProduct[];
-}
-export interface SubscriptionPurchaseInput {
-    planId: string;
-    provider?: 'mollie' | 'stripe';
-    mandateId?: string;
-    returnUrl: string;
-    /** Persist this key for the purchase; reuse it when retrying the same request. */
-    requestKey: string;
-    /**
-     * The previewed `amount`. When given, the purchase is rejected — before any
-     * payment starts — if the price changed since the preview; preview again.
-     */
-    expectedAmount?: number;
-}
-export interface SubscriptionPaymentActionInput {
-    requestKey: string;
-    returnUrl: string;
-    provider?: 'mollie' | 'stripe';
-}
-export interface SubscriptionLifecycleCommand {
+/**
+ * A subscription change as a storefront sends it: the schema's
+ * `SubscriptionLifecycleCommand` without `overrideReason` (staff only; the Shop
+ * API refuses it), with `action` one of the storefront actions. Reuse
+ * `requestKey` when retrying the same change.
+ */
+export type SubscriptionLifecycleCommand = Omit<Shop.SubscriptionLifecycleCommand, 'action' | 'overrideReason'> & {
     action: SubscriptionLifecycleAction;
-    requestKey: string;
-    date?: string;
-    reason?: string;
-}
-export interface SubscriptionChangePreview {
-    allowed: boolean;
-    reason: string | null;
-    nextRenewalAt: string | null;
-    cancellationEffectiveAt: string | null;
-    committedPayment: boolean;
-    remainingPaidCycles: number;
-}
-export interface SubscriptionPurchaseResult {
-    id: string;
-    subscriptionId: string;
-    state: string;
-    checkoutUrl: string | null;
-    expiresAt: string | null;
-    currentStatus: string | null;
-    paymentActionRequired: boolean;
-    nextRenewalAt: string | null;
-}
-export interface CustomerSubscription {
-    billingIntervalCount: number;
-    trialEndsAt: string | null;
-    minCycles: number | null;
-    maxCycles: number | null;
-    paidCycleCount: number;
-    firstChargeTiming: SubscriptionFirstChargeTiming;
-    customerChangeCutoffHours: number;
-    cutoffAt: string | null;
-    cancellationRequested: boolean;
-    cancellationEffectiveAt: string | null;
-    earliestCancellationAt: string | null;
-    remainingPaidCycles: number;
-    committedPayment: boolean;
-    resumeAt: string | null;
-    retainedResumeAt: string | null;
-    earliestResumeAt: string;
-    allowedActions: SubscriptionAllowedAction[];
-    products: SubscriptionProduct[];
-    paymentActionRequired: boolean;
-    upcomingPayment: SubscriptionUpcomingPayment;
-    id: string;
-    planName: string;
-    currencyCode: string;
-    recurringPrice: number;
-    billingInterval: string;
-    currentStatus: CustomerSubscriptionStatus | null;
-    currentPeriodStart: string | null;
-    currentPeriodEnd: string | null;
-    nextRenewalAt: string | null;
-    cancelAtPeriodEnd: boolean;
-    createdAt: string;
-}
-/** Customer-safe subscription plan for the storefront catalogue. */
-export interface SubscriptionPlanPublic {
-    firstChargeTiming: SubscriptionFirstChargeTiming;
-    customerChangeCutoffHours: number;
-    id: string;
-    name: string;
-    description: string | null;
-    currencyCode: string;
-    /**
-     * Price per cycle in minor units, shipping included, on the channel's price
-     * basis: gross when the channel's prices include tax, otherwise net. Use
-     * `previewSubscriptionPurchase` for the amount a customer is charged.
-     */
-    price: number;
-    billingInterval: string;
-    billingIntervalCount: number;
-    trialDays: number;
-    minCycles: number | null;
-    maxCycles: number | null;
-}
-/** Customer-safe view of a stored payment mandate. */
-export interface MyPaymentMandate {
-    id: string;
-    provider: string;
-    mandateMethod: string | null;
-    /** 'pending' | 'valid' | 'invalid' | 'revoked' */
-    mandateStatus: string;
-    isDefault: boolean;
-    createdAt: string;
-}
-export interface SetupPaymentMandateResult {
-    mandate: MyPaymentMandate;
-    /** Mollie checkout URL to redirect the customer to (null for Stripe). */
-    checkoutUrl: string | null;
-    /** Stripe SetupIntent client secret (null for Mollie). */
-    clientSecret: string | null;
-}
-export type QuoteStatus = 'draft' | 'requested' | 'in_review' | 'approved' | 'declined' | 'expired' | 'converted_to_order' | 'cancelled';
-export interface QuoteLine {
-    id: string;
-    productVariantId: string;
-    quantity: number;
-    /** Minor units in the quote currency. Null until a sales rep prices the line. */
-    unitPrice: number | null;
-    /**
-     * Line-level discount the rep applied. `percentage` is basis points
-     * (10000 = 100%); `fixed` is whole-line minor units. Null when no discount.
-     */
-    discountType: 'percentage' | 'fixed' | null;
-    /** Discount magnitude (basis points for `percentage`, minor units for `fixed`). */
-    discountValue: number;
-    discountLabel: string | null;
-    position: number;
-    /**
-     * Variant display name at read time, in the request's language. `null` when
-     * the variant has been deleted or left the channel — render a placeholder
-     * rather than scanning the catalogue for it.
-     *
-     * Optional, like the five fields below: they are `undefined` against a
-     * Vendure that predates them, which the client detects once and then stops
-     * asking for (see `createQuotesMethods`).
-     */
-    productName?: string | null;
-    /** Variant SKU at read time. `null` under the same conditions as `productName`. */
-    sku?: string | null;
-    /**
-     * Effective tax rate for this line as a PERCENT — 21 for 21%, and fractional
-     * where the statutory rate is (13.5 in IE, 8.1 in CH). It is the variant's
-     * own applied TaxRate, the rate the converted order is charged at; never
-     * assume a national rate. `null` when the variant is unavailable.
-     */
-    taxRate?: number | null;
-    /**
-     * Per-unit GROSS (incl. tax) price in minor units, with the whole-line
-     * discount already amortised across the units. `null` when the variant is
-     * unavailable, and while the line is still unpriced (`unitPrice` is `null`,
-     * i.e. a draft or requested quote) — render a placeholder, never `0`.
-     *
-     * Derived from `lineTotalWithTax / quantity`, so it is the quote's own
-     * agreed per-unit figure: `unitPriceWithTax × quantity` reconciles with the
-     * line total exactly, and may differ from the variant's catalogue gross
-     * unit price by a rounding unit.
-     */
-    unitPriceWithTax?: number | null;
-    /**
-     * NET (excl. tax) line total in minor units, after discount. `null` when the
-     * variant is unavailable or the line is still unpriced.
-     */
-    lineTotal?: number | null;
-    /**
-     * GROSS (incl. tax) line total in minor units, after discount — what this
-     * line adds to the payable total. `null` when the variant is unavailable or
-     * the line is still unpriced.
-     *
-     * This is the quote's OWN line maths. The order `acceptQuote` creates
-     * re-prices per unit, so an order total can differ from the sum of these by
-     * a minor unit per line when the discount does not divide evenly.
-     */
-    lineTotalWithTax?: number | null;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface Quote {
-    id: string;
-    code: string;
-    channelId: string;
-    customerId: string;
-    currencyCode: string;
-    status: QuoteStatus;
-    expiresAt: string | null;
-    salesRepUserId: string | null;
-    customerNotes: string | null;
-    /** Set once the quote has been accepted and converted to an Order. */
-    convertedOrderId: string | null;
-    lines: QuoteLine[];
-    createdAt: string;
-    updatedAt: string;
-}
-export interface QuoteList {
-    items: Quote[];
-    totalItems: number;
-}
-export interface QuoteListOptions {
-    take?: number;
-    skip?: number;
-    status?: QuoteStatus;
-}
-export interface CreateQuoteRequestInput {
-    items: Array<{
-        productVariantId: string;
-        quantity: number;
-    }>;
-    customerNotes?: string;
-}
+};
 /**
- * Lifecycle state of a return, derived from its status log. Customers can
- * only cancel while still `requested`; everything after that is merchant- or
- * system-driven.
+ * A subscription purchase as a storefront starts it: the schema's
+ * `SubscriptionPurchaseInput` without `customerId` (always the signed-in
+ * customer; the Shop API refuses another) and `sendPaymentEmail` (a staff
+ * option the Shop API ignores), with `provider` one of the providers the plugin
+ * has. Persist `requestKey` for the purchase and reuse it when retrying. Pass
+ * the previewed `amount` as `expectedAmount` to have the purchase refused —
+ * before any payment starts — if the price changed since the preview.
  */
-export type CustomerReturnState = 'requested' | 'approved' | 'rejected' | 'cancelled' | 'items_received' | 'settlement_pending' | 'settlement_failed' | 'settled';
-export type CustomerReturnSettlementMethod = 'refund' | 'store_credit';
-export type CustomerReturnReasonCode = 'damaged' | 'defective' | 'wrong_item' | 'not_as_described' | 'arrived_late' | 'no_longer_needed' | 'order_error' | 'other';
-export interface CustomerReturnLine {
-    id: string;
-    orderLineId: string;
-    productVariantId: string;
-    productVariantName: string;
-    productVariantSku: string;
-    requestedQty: number;
-    /** Null until the merchant approves; 0 means the line was declined. */
-    approvedQty: number | null;
-    /** Cumulative units received back by the merchant across all receipts. */
-    receivedQty: number;
-    restockQty: number;
-    writeOffQty: number;
-    reasonCode: CustomerReturnReasonCode;
-    reasonNote: string | null;
-    /** Snapshot of the order line's prorated unit price incl. tax (minor units). */
-    unitPriceWithTax: number;
-    /**
-     * The same snapshot before per-unit rounding; null for returns requested
-     * before the field existed. Multiply by a quantity and round ONCE to get
-     * that quantity's share, exactly as the order line totals itself.
-     */
-    unitPriceWithTaxUnrounded: number | null;
-    /** Refund amount for this line (minor units); null until approved. */
-    refundAmount: number | null;
-}
-/** A customer-facing return (RMA). All money fields are Int minor units. */
-export interface CustomerReturn {
-    id: string;
-    /** Human-facing RMA code, e.g. RMA-000042. */
-    code: string;
-    state: CustomerReturnState;
-    orderId: string;
-    orderCode: string;
-    currencyCode: string;
-    preferredSettlementMethod: CustomerReturnSettlementMethod | null;
-    /** Settlement method actually used; null until settled. */
-    settlementMethod: CustomerReturnSettlementMethod | null;
-    /** Shipping refunded on top of line refunds (minor units). */
-    shippingRefundAmount: number;
-    /** Total actually settled (minor units); null until settled. */
-    settledAmount: number | null;
-    customerNote: string | null;
-    requestedAt: string;
-    resolvedAt: string | null;
-    lines: CustomerReturnLine[];
-    createdAt: string;
-}
-export interface CustomerReturnList {
-    items: CustomerReturn[];
-    totalItems: number;
-}
-export interface CustomerReturnListOptions {
-    take?: number;
-    skip?: number;
-}
-export interface RequestReturnLineInput {
-    orderLineId: string;
-    quantity: number;
-    reasonCode: CustomerReturnReasonCode;
-    reasonNote?: string;
-}
-export interface RequestReturnInput {
-    orderId: string;
-    lines: RequestReturnLineInput[];
-    customerNote?: string;
-    preferredSettlementMethod?: CustomerReturnSettlementMethod;
-}
-/** Per-order-line returnable quantities for the return-request flow. */
-export interface ReturnableOrderLine {
-    orderLineId: string;
-    productVariantId: string;
-    productVariantName: string;
-    productVariantSku: string;
-    /** Units shipped or delivered for this order line. */
-    fulfilledQty: number;
-    /** fulfilledQty minus quantities tied up in active returns. */
-    returnableQty: number;
-    /** The order line's prorated unit price incl. tax (minor units). */
-    unitPriceWithTax: number;
-    /**
-     * The same price before per-unit rounding. Multiply by a quantity and round
-     * ONCE to preview that quantity's refund, exactly as the order line totals
-     * itself.
-     */
-    unitPriceWithTaxUnrounded: number;
-}
-export interface CustomerReturnEligibility {
-    orderId: string;
-    eligible: boolean;
-    /** Why the order is not eligible; null when eligible. */
-    reason: string | null;
-    returnWindowEndsAt: string | null;
-    /** Only lines with fulfilled quantity appear here. */
-    lines: ReturnableOrderLine[];
-}
+export type SubscriptionPurchaseInput = Omit<Shop.SubscriptionPurchaseInput, 'customerId' | 'sendPaymentEmail' | 'provider'> & {
+    provider?: 'mollie' | 'stripe' | null;
+};
 /**
- * The authenticated customer's B2B accounts-receivable credit status in the
- * current channel. All money fields are in minor units of `currencyCode`.
- * Returned by `client.credit.getCreditStatus()`; `null` when the customer is
- * not signed in, has no credit account, or the channel has B2B credit disabled.
+ * A payment action on a subscription (`recoverMySubscriptionPayment`,
+ * `replaceMySubscriptionMandate`): the schema's `SubscriptionPaymentActionInput`
+ * with `provider` one of the providers the plugin has.
  */
-export interface B2bCreditStatus {
-    customerId: string;
-    currencyCode: string;
-    /** Outstanding invoiced-but-unpaid ledger balance. */
-    balance: number;
-    /** Total value of placed B2B orders not yet invoiced. */
-    uninvoicedOrdersTotal: number;
-    /** Total credit exposure (`balance + uninvoicedOrdersTotal`). */
-    exposure: number;
-    /** Configured credit limit; `null` when no limit is set. */
-    creditLimit: number | null;
-    /** Remaining headroom (`creditLimit - exposure`); `null` when no limit is set. */
-    available: number | null;
-    overdueInvoiceCount: number;
-    overLimit: boolean;
-    hasOverdue: boolean;
-    /**
-     * Where `balance` was sourced from. `LOCAL_LEDGER` = computed from the local
-     * AR subledger; `ERP_LIVE` = read live from the ERP; `ERP_UNLINKED` = the
-     * channel is ERP-driven but this customer isn't linked yet (treat the balance
-     * as unavailable rather than zero, and surface a "not linked" notice).
-     */
-    balanceSource: CreditBalanceSource;
-}
-/** Where a {@link B2bCreditStatus.balanceSource} balance was sourced from. */
-export type CreditBalanceSource = 'LOCAL_LEDGER' | 'ERP_LIVE' | 'ERP_UNLINKED';
-/** How reliably the source payment condition could be interpreted. */
-export type PaymentTermsClassification = 'SINGLE_DUE_DATE' | 'COMPLEX' | 'UNRESOLVED' | 'UNASSIGNED' | 'CONFLICT';
-/** Assignment and freshness state for externally managed customer payment terms. */
-export type PaymentTermsStatus = 'ASSIGNED' | 'UNASSIGNED' | 'UNRESOLVED' | 'STALE' | 'CONFLICT';
+export type SubscriptionPaymentActionInput = Omit<Shop.SubscriptionPaymentActionInput, 'provider'> & {
+    provider?: 'mollie' | 'stripe' | null;
+};
 /**
- * Source-aware payment terms for the authenticated customer. Exact-backed terms preserve the
- * original condition code and complex-rule fields rather than reducing every condition to days.
+ * A quote line as either quote document answers it. The client retries a quote
+ * document without the six per-line fields — `productName`, `sku`, `taxRate`,
+ * `unitPriceWithTax`, `lineTotal`, `lineTotalWithTax` — once an engine refuses
+ * them (and then stops asking), so those six are optional: `undefined` against
+ * such an engine, `null` where the engine has nothing (an unpriced line, a
+ * variant that left the channel).
  */
-export interface CustomerPaymentTerms {
-    customerId: string | null;
-    source: string;
-    managedExternally: boolean;
-    status: PaymentTermsStatus;
-    conditionCode: string | null;
-    conditionDescription: string | null;
-    summary: string;
-    classification: PaymentTermsClassification;
-    paymentDays: number | null;
-    paymentEndOfMonths: number | null;
-    paymentMethod: string | null;
-    percentage: number | null;
-    discountPaymentDays: number | null;
-    discountPercentage: number | null;
-    paymentDiscountType: string | null;
-    stale: boolean;
-    syncedAt: string | null;
-    error: string | null;
-}
-/** Payment terms frozen on an order at acceptance, including later remote confirmation metadata. */
-export interface OrderPaymentTermsSnapshot extends Omit<CustomerPaymentTerms, 'customerId'> {
-    resolvedAt: string;
-    remoteConditionCode: string | null;
-    remoteConfirmedAt: string | null;
-    /** True after the ERP confirms a different condition than the accepted snapshot. */
-    remoteMismatch: boolean;
-}
-/** Assignment and freshness state for Exact-managed customer delivery terms. */
-export type DeliveryTermsStatus = 'ASSIGNED' | 'UNASSIGNED' | 'UNRESOLVED' | 'STALE' | 'CONFLICT';
-/** Exact's account-level partial-delivery policy, exposed as operational guidance. */
-export type DeliveryAdvice = 'PARTIAL_ALLOWED' | 'COMPLETE_ORDER' | 'PARTIAL_WITHOUT_BACKORDER' | 'UNKNOWN';
-/** Why the placed order uses its selected shipping method. */
-export type DeliverySelectionSource = 'CUSTOMER_DEFAULT' | 'EXPLICIT_OVERRIDE' | 'IMPORTED' | 'UNKNOWN';
+export type QuoteLine = Shop.QuoteLegacyFragment['lines'][number] & Partial<Omit<Shop.QuoteFragment['lines'][number], keyof Shop.QuoteLegacyFragment['lines'][number]>>;
+/** A quote as either quote document answers it — see {@link QuoteLine}. */
+export type Quote = Omit<Shop.QuoteFragment, 'lines'> & {
+    lines: QuoteLine[];
+};
+/** One page of `getMyQuotes`. */
+export type QuoteList = Omit<Shop.MyQuotesQuery['myQuotes'], 'items'> & {
+    items: Quote[];
+};
 /**
- * Exact-aware delivery terms for the authenticated customer in the current channel.
- * The preferred method is a default, not an eligibility restriction; checkout pricing
- * still comes from the platform's shipping calculator.
+ * The authenticated customer's B2B accounts-receivable credit status in the
+ * current channel, as either credit document answers it. All money fields are
+ * in minor units of `currencyCode`, the credit account's currency (the credit
+ * limit's) — NOT the session currency. Money the customer owes in another
+ * currency (orders placed in it) is converted into `currencyCode` at the
+ * store's exchange rate. Returned by `client.credit.getCreditStatus()`; `null`
+ * when the customer is not signed in, has no credit account, or the channel has
+ * B2B credit disabled. `balanceSource` `ERP_UNLINKED` means the balance is
+ * unavailable, not zero.
+ *
+ * `unconvertedCurrencies`: currencies the customer owes money in that the store
+ * has no exchange rate for, and that are therefore NOT in `balance` /
+ * `uninvoicedOrdersTotal` / `exposure`. Only ever non-empty when there is no
+ * credit limit (with a limit the status is refused instead). When non-empty,
+ * say the figures are incomplete rather than show them as everything owed.
+ * `undefined` from an engine released before 2026-10-01 — the client retries
+ * that engine with a document without the field — which never leaves money out.
  */
-export interface CustomerDeliveryTerms {
-    customerId: string | null;
-    source: string;
-    managedExternally: boolean;
-    status: DeliveryTermsStatus;
-    shippingMethodStatus: DeliveryTermsStatus;
-    policyStatus: DeliveryTermsStatus;
-    summary: string;
-    preferredShippingMethodId: string | null;
-    preferredShippingMethodCode: string | null;
-    preferredShippingMethodName: string | null;
-    preferredShippingMethodAvailable: boolean;
-    /** Active platform mappings that may be selected as deliberate overrides. */
-    eligibleShippingMethodIds: string[];
-    incotermStatus: DeliveryTermsStatus;
-    incotermCode: string | null;
-    incotermVersion: number | null;
-    incotermAddress: string | null;
-    incotermDescription: string | null;
-    /** Exact dispatch lead time in days; this is not a promised arrival date. */
-    shippingLeadDays: number | null;
-    deliveryAdvice: DeliveryAdvice | null;
-    stale: boolean;
-    syncedAt: string | null;
-    /** Customer-safe warning; raw synchronization errors remain Admin-only. */
-    warning: string | null;
-}
-/** Delivery terms frozen on an order at acceptance, plus later Exact readback metadata. */
-export interface OrderDeliveryTermsSnapshot {
-    source: string;
-    managedExternally: boolean;
-    status: DeliveryTermsStatus;
-    shippingMethodStatus: DeliveryTermsStatus;
-    policyStatus: DeliveryTermsStatus;
-    summary: string;
-    selectionSource: DeliverySelectionSource;
-    selectedShippingMethodId: string | null;
-    selectedShippingMethodCode: string | null;
-    selectedShippingMethodName: string | null;
-    platformShippingMethodCode: string | null;
-    platformShippingMethodName: string | null;
-    platformShippingMethodDescription: string | null;
-    /** Accepted platform shipping quote in order-currency minor units. */
-    platformShippingPrice: number | null;
-    /** Accepted platform shipping quote including tax, in order-currency minor units. */
-    platformShippingPriceWithTax: number | null;
-    preferredShippingMethodId: string | null;
-    incotermStatus: DeliveryTermsStatus;
-    incotermCode: string | null;
-    incotermVersion: number | null;
-    incotermAddress: string | null;
-    incotermDescription: string | null;
-    shippingLeadDays: number | null;
-    deliveryAdvice: DeliveryAdvice | null;
-    stale: boolean;
-    syncedAt: string | null;
-    warning: string | null;
-    resolvedAt: string;
-    remoteShippingMethodCode: string | null;
-    remoteShippingMethodName: string | null;
-    remoteIncotermCode: string | null;
-    remoteIncotermVersion: number | null;
-    remoteIncotermAddress: string | null;
-    remoteDeliveryDate: string | null;
-    remoteConfirmedAt: string | null;
-    /** True after Exact confirms delivery fields that differ from the accepted snapshot. */
-    remoteMismatch: boolean;
-}
-export interface VatValidationResult {
-    status: string;
-    vatNumber: string;
-    countryCode: string;
-    companyName: string | null;
-    companyAddress: string | null;
-    validatedAt: string | null;
-    error: string | null;
-}
-export interface DropOffPointInput {
-    postalCode: string;
-    countryCode?: string;
-    carrierId?: string;
+export type B2bCreditStatus = Shop.B2bCreditStatusLegacyFragment & Partial<Pick<Shop.B2bCreditStatusFragment, 'unconvertedCurrencies'>>;
+export interface CustomerReturnListOptions {
+    take?: number;
+    skip?: number;
 }
 export interface DropOffPoint {
     locationCode: string;
@@ -3088,16 +1250,6 @@ export interface DropOffPoint {
     /** Distance from the postal code, in metres. */
     distance: number | null;
 }
-export interface DeliveryOptionsInput {
-    postalCode: string;
-    countryCode?: string;
-    carrierId?: number;
-    deliveryDate?: string;
-    cutoffTime?: string;
-    mondayDelivery?: boolean;
-    saturdayDelivery?: boolean;
-    dropoffDays?: string;
-}
 export interface DeliveryTimeFrame {
     start: string;
     end: string;
@@ -3144,19 +1296,6 @@ export interface PickupLocation {
     /** Carrier-specific extras. */
     details?: Record<string, unknown>;
 }
-export interface PickupLocationSearchInput {
-    /** ISO 3166-1 alpha-2 country code. */
-    countryCode: string;
-    postalCode: string;
-    carrierId: number;
-    city?: string;
-    street?: string;
-    number?: string;
-    latitude?: number;
-    longitude?: number;
-    /** Search radius in metres. */
-    distance?: number;
-}
 export interface ShipmentTrackingHistoryEntry {
     status: number;
     time: string;
@@ -3172,9 +1311,46 @@ export interface ShipmentTrackingInfo {
     consumerPortalLink: string | null;
 }
 export interface CommerceModule {
-    getProduct(slug: string, options?: RequestOptions): Promise<Product>;
-    getProductById(id: string, options?: RequestOptions): Promise<Product>;
-    getProducts(listOptions?: ProductListOptions, options?: RequestOptions): Promise<PaginatedList<ProductSummary>>;
+    /**
+     * A product by slug. `{ metafields: true }` (or `{ metafields: { namespace }
+     * }`) also returns its storefront-visible metafields and each variant's in
+     * the same request; it needs an engine serving `Product.metafields`.
+     */
+    getProduct(slug: string, options: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields: true | {
+            namespace: string;
+        };
+    }): Promise<import('./commerce/products.js').ProductWithMetafields>;
+    getProduct(slug: string, options?: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields?: false;
+    }): Promise<Product>;
+    getProduct(slug: string, options?: import('./commerce/products.js').CatalogDetailOptions): Promise<Product | import('./commerce/products.js').ProductWithMetafields>;
+    /** {@link CommerceModule.getProduct} by id, tagged `product:<id>`. */
+    getProductById(id: string, options: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields: true | {
+            namespace: string;
+        };
+    }): Promise<import('./commerce/products.js').ProductWithMetafields>;
+    getProductById(id: string, options?: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields?: false;
+    }): Promise<Product>;
+    getProductById(id: string, options?: import('./commerce/products.js').CatalogDetailOptions): Promise<Product | import('./commerce/products.js').ProductWithMetafields>;
+    /** Grid-tile rows — see {@link ProductListOptions.detail}. */
+    getProducts(listOptions: ProductListOptions & {
+        detail: 'card';
+        collectionSlug?: undefined;
+    }, options?: RequestOptions): Promise<PaginatedList<Shop.ProductCardFragment>>;
+    /** Full list rows, the default. */
+    getProducts(listOptions?: ProductListOptions & {
+        detail?: 'full';
+        collectionSlug?: undefined;
+    }, options?: RequestOptions): Promise<PaginatedList<Shop.ProductSummaryFragment>>;
+    /**
+     * Any other options — not literals, or the deprecated `collectionSlug`: any
+     * of the three row shapes. `collectionSlug` reroutes to search rows only
+     * when it is non-empty, which its type cannot say.
+     */
+    getProducts(listOptions?: ProductListOptions, options?: RequestOptions): Promise<ProductListPage>;
     getProductsInCollection(collectionSlug: string, listOptions?: CollectionProductListOptions, options?: RequestOptions): Promise<PaginatedList<CollectionProductSummary>>;
     /**
      * `getProductsInCollection` by collection id — typically `route.id` from the
@@ -3182,33 +1358,178 @@ export interface CommerceModule {
      * so `collection.membership_changed` purges the listing.
      */
     getProductsInCollectionById(collectionId: string, listOptions?: CollectionProductListOptions, options?: RequestOptions): Promise<PaginatedList<CollectionProductSummary>>;
-    getFacets(options?: RequestOptions): Promise<Facet[]>;
-    searchProducts(input: SearchInput, options?: RequestOptions): Promise<SearchResult>;
-    getActiveOrder(): Promise<Order | null>;
-    addToCart(variantId: string, quantity: number): Promise<Order>;
+    getFacets(options?: RequestOptions): Promise<Shop.FacetFragment[]>;
+    searchProducts(input: SearchInput, options?: RequestOptions): Promise<Shop.SearchResultFragment>;
+    getActiveOrder(): Promise<Shop.OrderFragment | null>;
+    /**
+     * Refused with `StorefrontError` `VARIANT_NOT_FOR_SALE_IN_CURRENCY` (422) when
+     * the store does not sell the product in the client's currency, and when the
+     * cart holds a product it does not sell there (see `setOrderCurrency`). So are
+     * `addItemsToCart` and `updateCartLine`; the cart is left as it was.
+     *
+     * Refused with `StorefrontError` `PRODUCT_EXCLUDED_FROM_STORE` (422, an engine
+     * released on or after 2026-10-05) when the store no longer sells the product;
+     * so are `addItemsToCart` (the whole call) and `updateCartLine` raising such a
+     * line. Lowering or removing a line always works.
+     */
+    addToCart(variantId: string, quantity: number): Promise<Shop.OrderFragment>;
     /** Add several variants in one call (e.g. favourite-box bundles). */
-    addItemsToCart(items: Array<{
-        productVariantId: string;
-        quantity: number;
-    }>): Promise<Order>;
-    updateCartLine(lineId: string, quantity: number): Promise<Order>;
-    removeFromCart(lineId: string): Promise<Order>;
+    addItemsToCart(items: Shop.AddItemInput[]): Promise<Shop.OrderFragment>;
+    updateCartLine(lineId: string, quantity: number): Promise<Shop.OrderFragment>;
+    removeFromCart(lineId: string): Promise<Shop.OrderFragment>;
     /** Remove every line from the active order, leaving an empty cart. */
-    clearCart(): Promise<Order>;
-    applyCouponCode(code: string): Promise<Order>;
-    removeCouponCode(code: string): Promise<Order>;
-    setCustomerForOrder(input: CustomerInput): Promise<Order>;
-    setShippingAddress(input: AddressInput): Promise<Order>;
-    setBillingAddress(input: AddressInput): Promise<Order>;
-    getEligibleShippingMethods(): Promise<ShippingMethod[]>;
+    clearCart(): Promise<Shop.OrderFragment>;
+    applyCouponCode(code: string): Promise<Shop.OrderFragment>;
+    /** `null` when there is no active order to remove the code from. */
+    removeCouponCode(code: string): Promise<Shop.OrderFragment | null>;
+    setCustomerForOrder(input: Shop.CreateCustomerInput): Promise<Shop.OrderFragment>;
+    setShippingAddress(input: Shop.CreateAddressInput): Promise<Shop.OrderFragment>;
+    setBillingAddress(input: Shop.CreateAddressInput): Promise<Shop.OrderFragment>;
+    /**
+     * Remove the delivery address from the active order (engine 3.1+) and
+     * return it re-priced: with no address the order falls back to the channel's
+     * default tax zone. Drops the cached tax display mode, like
+     * {@link CommerceModule.setShippingAddress}. `NO_ACTIVE_ORDER_ERROR` throws
+     * `MutationError`.
+     */
+    unsetShippingAddress(options?: RequestOptions): Promise<Shop.OrderFragment>;
+    /**
+     * Remove the billing address from the active order (engine 3.1+).
+     * `NO_ACTIVE_ORDER_ERROR` throws `MutationError`.
+     */
+    unsetBillingAddress(options?: RequestOptions): Promise<Shop.OrderFragment>;
+    /**
+     * Write order custom fields on the active order; returns the order with the
+     * writable fields (`customFields`) as the engine stored them.
+     *
+     * Writable are exactly the members of `UpdateOrderCustomFieldsInput`
+     * (the engine's public, non-read-only order fields): `isGift`, `giftNote`,
+     * `hidePricesOnPackingSlip`, `poNumber` (≤ 255 characters),
+     * `requestedDeliveryDate`, `orderNotes` (≤ 5000 characters) and the
+     * sixtynine.email attribution fields `snTid`, `snUtmSource`, `snUtmMedium`,
+     * `snUtmCampaign`, `snFlowId`, `snEnrollmentId`, `snStepId`. `null` clears
+     * a field; one left out is left as it is.
+     *
+     * `requestedDeliveryDate` is a DAY, sent as midnight UTC of that day
+     * (`2026-10-14T00:00:00.000Z`); the engine refuses a day before yesterday
+     * (UTC) or more than 400 days ahead.
+     *
+     * `paymentIntent`, `orderScope` and `chargedParcelCount` are readable, never
+     * writable here: set the intent with {@link CommerceModule.setPaymentIntent},
+     * which re-prices the order in the same call. Naming one of them, or passing
+     * a `fields` that is not an object, throws a 400 `INVALID_ARGUMENT` before
+     * any request. A value the engine's validation refuses (a 256-character
+     * `poNumber`, a past delivery day) throws its `StorefrontError`;
+     * `NO_ACTIVE_ORDER_ERROR` throws `MutationError`.
+     *
+     * The returned `customFields` selects the attribution fields, so this call
+     * needs an engine that has them (released 2026-09-22).
+     */
+    setOrderCustomFields(fields: Shop.UpdateOrderCustomFieldsInput, options?: RequestOptions): Promise<import('./commerce/checkout.js').OrderWithWritableCustomFields>;
+    /**
+     * Switch the shopper to another of the channel's currencies: the active
+     * order comes back re-priced in it, and from then on this client names the
+     * currency on every Shop API request (`?currencyCode=`), so catalogue prices,
+     * later cart changes and checkout all stay in it and `pricing.format*`
+     * default to it. (The engine re-prices an order into the REQUEST's currency
+     * on every change; a request that names none is the channel default.)
+     * Persist the code and pass it as `createStorefrontClient({ currencyCode })`
+     * to restore the choice on a new client, e.g. on the next server render.
+     *
+     * Only while the order is a cart (`AddingItems`); later states throw
+     * `MutationError` `ORDER_MODIFICATION_ERROR` and the client keeps its
+     * currency. A currency the store does not offer
+     * (`ActiveChannel.availableCurrencyCodes`) is refused with
+     * `StorefrontError` `CURRENCY_NOT_AVAILABLE` (400); a value that is not three
+     * upper-case letters throws a 400 `INVALID_ARGUMENT` before any request. The
+     * order's current currency returns it unchanged. Like the engine, it creates
+     * an empty active order when there is none.
+     *
+     * A cart holding a product the store does not sell in `currencyCode` (its
+     * `forSaleInCurrency` is `false` there) is refused with `StorefrontError`
+     * `VARIANT_NOT_FOR_SALE_IN_CURRENCY` (422, an engine released on or after
+     * 2026-10-03): the cart and the client keep their currency, and the message
+     * is a sentence for the buyer naming the currency. The buyer removes those
+     * products, or stays in the current currency. The same refusal answers any
+     * cart change sent in such a currency, e.g. a restored
+     * `createStorefrontClient({ currencyCode })` the cart was never switched to;
+     * `setOrderCurrency(order.currencyCode)` then puts the client back on the
+     * cart's currency. Removing those products works in the cart's currency; in
+     * another one the rest of the cart is re-priced into it, so a removal there
+     * goes through only once no such product is left.
+     *
+     * Money the store sets in its DEFAULT currency, in another currency (an
+     * engine released on or after 2026-09-30): order minimums (channel,
+     * price-list and delivery-profile; `getOrderConstraints()`) are converted into
+     * the order's currency at the rate checkout charges with. With no exchange
+     * rate for that currency, checkout is refused while an amount minimum applies
+     * (`PLACEMENT_BLOCKED`, `details[0].code` `EXCHANGE_RATE_UNAVAILABLE`) and the
+     * shopper can switch back to the default currency. A price-list money figure
+     * without its own currency (a fixed price, or a fixed amount off) applies
+     * ONLY in the default currency: in another currency that entry is skipped and
+     * the next applicable price-list rule applies, or else the product's own price
+     * in that currency. Percentage discounts apply in every currency. An older
+     * engine applied both minimums and those figures to another currency
+     * unconverted, so there offer only the default currency. A fixed price or
+     * amount the store set for THIS order (one-time pricing) applies only in the
+     * currency it was set in (engine 2026-10-01): switching the cart away drops it.
+     */
+    setOrderCurrency(currencyCode: Shop.CurrencyCode, options?: RequestOptions): Promise<Shop.OrderFragment>;
+    /**
+     * The shipping methods the active order can ship with now. `metadata` is the
+     * method's quote detail (a JSON value); `readParcelPricing(method.metadata)`
+     * reads the extra-parcel charge from it.
+     */
+    getEligibleShippingMethods(): Promise<Shop.ShippingMethodsQuery['eligibleShippingMethods']>;
+    /**
+     * Every shipping method the channel offers in its storefront, whatever the
+     * active order — for a delivery-options page. Methods switched off or
+     * withheld from the storefront are left out by the engine.
+     *
+     * Not the checkout list: it ignores the order's address, weight and value.
+     * Offer {@link CommerceModule.getEligibleShippingMethods} (or
+     * `getEligibleShippingRates`) at checkout.
+     */
+    getActiveShippingMethods(options?: RequestOptions): Promise<Shop.PublicShippingMethodFragment[]>;
     /** Exact-aware delivery defaults for the signed-in customer, or null when unavailable. */
-    getDeliveryTerms(options?: RequestOptions): Promise<CustomerDeliveryTerms | null>;
-    setShippingMethod(ids: string[]): Promise<Order>;
+    getDeliveryTerms(options?: RequestOptions): Promise<Shop.MyDeliveryTermsQuery['myDeliveryTerms']>;
+    setShippingMethod(ids: string[]): Promise<Shop.OrderFragment>;
+    /**
+     * Every way the active order can ship now, cheapest first: each platform
+     * method and each rate of each installed shipping-rates app (`source: 'app'`).
+     * While an app cannot be asked, its rates are left out and the platform's
+     * methods stay; the rate the order already carries is kept for 30 minutes
+     * after the app last quoted it. `selected` marks the order's current choice.
+     * Needs an engine with the `shipping.rates` hook (the query is new).
+     */
+    getEligibleShippingRates(): Promise<Shop.ShippingRatesQuery['eligibleShippingRates']>;
+    /**
+     * Ship the active order with a platform method (`rateCode` omitted) or one
+     * rate of an app (`rateCode` from `getEligibleShippingRates`; omitted picks the
+     * app's cheapest). Returns the re-priced order. A rate the app no longer
+     * offers throws `MutationError` `INELIGIBLE_SHIPPING_METHOD_ERROR`; list the
+     * rates again. Placement re-asks the app and refuses
+     * `SHIPPING_RATE_UNAVAILABLE` when the chosen rate was withdrawn or re-priced,
+     * or its app is down and the quote is older than 30 minutes.
+     */
+    setShippingRate(shippingMethodId: string, rateCode?: string | null): Promise<Shop.OrderFragment>;
     /** Apply the signed-in customer's currently eligible Exact default shipping method. */
-    applyPreferredShippingMethod(): Promise<Order>;
-    getEligiblePaymentMethods(): Promise<PaymentMethod[]>;
+    applyPreferredShippingMethod(): Promise<Shop.OrderFragment>;
+    getEligiblePaymentMethods(): Promise<Shop.PaymentMethodsQuery['eligiblePaymentMethods']>;
+    /**
+     * Every payment method the store offers in its storefront, whatever the
+     * active order — for a "we accept" strip. The engine leaves out methods
+     * withheld from the storefront and pay-later (net-terms) methods, which are
+     * granted per customer. (An engine without the storefront filter, merged
+     * 2026-09-30, listed every enabled method, staff-only ones included.)
+     *
+     * NOT the checkout list: it is not judged against the order, so a method
+     * listed here can still be ineligible. Offer
+     * {@link CommerceModule.getEligiblePaymentMethods} at checkout.
+     */
+    getActivePaymentMethods(options?: RequestOptions): Promise<Shop.PublicPaymentMethodFragment[]>;
     /** Order minimums on the active channel — display/pre-validation; server enforces. */
-    getOrderConstraints(): Promise<ActiveChannelOrderConstraints>;
+    getOrderConstraints(): Promise<Shop.ActiveChannelOrderConstraintsQuery['activeChannelOrderConstraints']>;
     /**
      * Record how the buyer intends to settle this order and return the
      * **re-priced** order — a pay-now discount promotion only applies once the
@@ -3217,11 +1538,176 @@ export interface CommerceModule {
      * looking at were computed. Call it whenever the buyer picks or changes a
      * payment method, before {@link CommerceModule.transitionToArrangingPayment}.
      */
-    setPaymentIntent(intent: OrderPaymentIntent): Promise<Order>;
-    transitionToArrangingPayment(): Promise<Order>;
-    addPayment(input: PaymentInput): Promise<Order>;
+    setPaymentIntent(intent: Shop.OrderPaymentIntent): Promise<Extract<Shop.SetOrderPaymentIntentMutation['setOrderPaymentIntent'], Shop.OrderFragment>>;
+    transitionToArrangingPayment(): Promise<Shop.OrderFragment>;
+    /**
+     * The states the active order may move to next. A listed state can still be
+     * refused by a guard when {@link CommerceModule.transitionOrder} asks for it:
+     * this is the state machine's edges, not a promise. Like the engine, it
+     * creates an empty active order (and a session) when there is none.
+     */
+    getNextOrderStates(options?: RequestOptions): Promise<string[]>;
+    /**
+     * Ask the engine to move the active order to `state` — the general form of
+     * {@link CommerceModule.transitionToArrangingPayment}, e.g. `AddingItems` to
+     * let the shopper edit the cart again after `ArrangingPayment`.
+     *
+     * The SDK decides nothing: the engine's order process and its guards (order
+     * minimums, stock, app checks, a parked order's hold, payment) judge every
+     * request, and a refusal throws `MutationError` `ORDER_STATE_TRANSITION_ERROR`
+     * — `error.code` carries the structured reason when there is one and
+     * `error.message` is safe to show the shopper. A blank `state` throws a 400
+     * `INVALID_ARGUMENT` before any request.
+     *
+     * A placed state (`PaymentAuthorized`, `PaymentSettled`, …) is reached by
+     * PAYING — {@link CommerceModule.addPayment} places the order once its
+     * payments cover it. Asked for directly on an order that is not paid, it is
+     * refused with `error.code === 'PLACEMENT_BLOCKED'` and
+     * `error.placement.details[0].code === 'PAYMENT_REQUIRED'`. (An engine
+     * without the shop payment guard, merged 2026-09-30, placed it unpaid.) A
+     * zero-total order places without a payment.
+     */
+    transitionOrder(state: string, options?: RequestOptions): Promise<Shop.OrderFragment>;
+    /**
+     * Pay the active order (it must be in `ArrangingPayment`).
+     *
+     * Every call carries an idempotency key: yours, or a fresh UUIDv7 when you
+     * pass none, and every error it throws carries it as `error.idempotencyKey`.
+     * A repeat under the same key is answered with the FIRST attempt's result
+     * (the placed order, or the same refusal) and never takes a second payment;
+     * the same key with a different `input` is refused `IDEMPOTENCY_CONFLICT`.
+     *
+     * - **Pass one key per checkout attempt**: mint it when the buyer presses
+     *   Pay and reuse it for that press, so a double click is one payment too.
+     *   After a definite refusal (declined, ineligible), the next press is a new
+     *   attempt with a new key.
+     * - **An error with `outcomeUnknown`** (the answer never came) is repeated
+     *   with `{ idempotencyKey: error.idempotencyKey }`. Never repeat it under a
+     *   new key: the first payment may have gone through.
+     * - **`IDEMPOTENCY_IN_PROGRESS`** (the first attempt under this key is still
+     *   running) is waited out for you, for up to 20 seconds, and you get the
+     *   first attempt's answer.
+     * - **`ORDER_BUSY`** (another change of the same cart was still being
+     *   applied, so this call paid nothing) is waited out the same way, inside
+     *   the same 20 seconds, and the payment then runs. Thrown after that, it is
+     *   repeated with `{ idempotencyKey: error.idempotencyKey }`.
+     * - **`IDEMPOTENCY_OUTCOME_UNKNOWN`**: the first attempt reached a payment
+     *   provider and failed, so whether money moved is unknown. Read the order
+     *   before doing anything else; this key will not run again.
+     *
+     * A key belongs to one cart. Reused on another cart, a guest's key pays that
+     * cart as a new payment, and a signed-in shopper's key is refused
+     * `IDEMPOTENCY_CONFLICT` (never answered with the first cart's order): mint a
+     * new key per attempt. The key travels as a header, which an engine older
+     * than this release ignores (there a repeat is a second request, as before).
+     *
+     * **A deposit instead of the whole order:** pass `amount` (minor units of the
+     * order's currency) and the call pays that much through
+     * {@link CommerceModule.payDeposit} instead, under the same key handling —
+     * read there who may, which methods, and what follows: the order leaves the
+     * cart and the store HOLDS it. It resolves to that held order (`state`
+     * `Parked`), in the same shape a full payment resolves to; call `payDeposit`
+     * itself to get the payment and the position too.
+     *
+     * The SDK routes on the PRESENCE of `amount`, never on its size: it cannot
+     * see what the order still bills without a second read, so the engine
+     * judges. An amount equal to the whole balance is refused
+     * `AMOUNT_NOT_A_DEPOSIT` — omit `amount` to pay in full — and more than the
+     * balance `AMOUNT_EXCEEDS_OUTSTANDING`. A card deposit (Mollie) is opened
+     * with {@link CommerceModule.createDepositPaymentIntent}, not here. An
+     * `amount` that is not a whole number throws a 400 `INVALID_ARGUMENT` before
+     * any request. Without `amount` the call is exactly the full payment above.
+     */
+    addPayment(input: Shop.PaymentInput, options?: RequestOptions & {
+        idempotencyKey?: string;
+        amount?: number;
+    }): Promise<Extract<Shop.AddPaymentMutation['addPaymentToOrder'], Shop.OrderFragment>>;
+    /**
+     * Pay a DEPOSIT on the active order in checkout (it must be in
+     * `ArrangingPayment`) with a method the store takes OFFLINE (bank transfer,
+     * invoice), and have the store HOLD the order until the shopper pays the rest.
+     *
+     * Needs a signed-in shopper — a guest is refused `DEPOSIT_REQUIRES_SIGN_IN`,
+     * since the rest is paid through {@link CommerceModule.payParkedOrder}, which
+     * only a signed-in customer can call — and a store that takes deposits
+     * (`DEPOSITS_NOT_ENABLED` otherwise), takes them online
+     * (`STOREFRONT_DEPOSITS_NOT_ENABLED`), and takes them with this method
+     * (`PAYMENT_METHOD_NOT_ALLOWED_FOR_DEPOSIT`).
+     *
+     * The order then leaves the cart: {@link CommerceModule.getActiveOrder}
+     * returns a fresh one, and this order is a held order in
+     * {@link CommerceModule.getParkedOrders}, its stock kept for the shopper,
+     * paid off with {@link CommerceModule.payParkedOrder} (or
+     * {@link CommerceModule.createParkedOrderPaymentIntent} for a card).
+     * `settled` is `false`: nothing is placed until the rest is paid. `position`
+     * is what the order bills, what is covered and what is left.
+     *
+     * A card method is refused `PAYMENT_METHOD_UNUSABLE_HERE`: open a card
+     * deposit with {@link CommerceModule.createDepositPaymentIntent} (Mollie;
+     * Stripe takes no deposits in this release —
+     * `PAYMENT_METHOD_NOT_ALLOWED_FOR_DEPOSIT`).
+     *
+     * `amount` is in minor units of the order's currency and must be LESS than
+     * what the order owes. Exactly the balance is `AMOUNT_NOT_A_DEPOSIT` (pay it
+     * with {@link CommerceModule.addPayment} and no amount); more is
+     * `AMOUNT_EXCEEDS_OUTSTANDING`; too little is `AMOUNT_BELOW_MINIMUM`, whose
+     * shopper-safe message names the least deposit the store asks for. The
+     * engine also sends that floor as `extensions.minimum` (the least the order
+     * must be covered to, minor units of its currency), but this SDK's errors
+     * carry a GraphQL error's `code`, `message` and `details` only — not its
+     * other extensions — so `error.minimum` does not exist: show the message.
+     * When the store's minimum is the whole order or more, no deposit can meet
+     * it and every amount is `DEPOSIT_MINIMUM_COVERS_ORDER`: offer the full
+     * payment instead.
+     * A non-integer `amount` throws a 400 `INVALID_ARGUMENT` before any request.
+     *
+     * Keyed like {@link CommerceModule.addPayment}: pass one key per payment
+     * attempt (or let the SDK mint a UUIDv7); a repeat under it returns the
+     * first deposit instead of paying twice, `IDEMPOTENCY_IN_PROGRESS` and
+     * `ORDER_BUSY` are waited out, and every error carries
+     * `error.idempotencyKey`.
+     *
+     * The other refusals, each a `StorefrontError` with the reason as `code`:
+     * `ORDER_NOT_FOUND` (no order in checkout), `ORDER_NOT_PARKABLE` (the order
+     * is not in `ArrangingPayment`), `ORDER_HELD_FOR_REVIEW`,
+     * `PAYMENT_METHOD_NOT_FOUND`, `AMOUNT_NOT_POSITIVE`,
+     * `EXCHANGE_RATE_UNAVAILABLE`, `INSUFFICIENT_STOCK` (nothing was paid),
+     * `PAYMENT_DECLINED`, and a placement rejection code (`PLACEMENT_BLOCKED`,
+     * `PAYMENT_TERMS_UNAVAILABLE`, …) when the store's payment rules refuse the
+     * method. An engine older than this release does not know the mutation
+     * (`GRAPHQL_VALIDATION_FAILED`).
+     */
+    payDeposit(input: Shop.PayDepositInput, options?: RequestOptions & {
+        idempotencyKey?: string;
+    }): Promise<Shop.PayDepositMutation['payDeposit']>;
+    /**
+     * Open a CARD payment (Mollie) for a DEPOSIT on the active order in checkout,
+     * and send the shopper to the returned `url`.
+     *
+     * Nothing is paid by this call and the order does not change: when the
+     * provider confirms the payment, the deposit is recorded and the store holds
+     * the order exactly as {@link CommerceModule.payDeposit} does. After the
+     * shopper comes back to `redirectUrl`, read
+     * {@link CommerceModule.getParkedOrders} — the provider's confirmation may
+     * lag the redirect by a few seconds.
+     *
+     * Same conditions and refusals as `payDeposit` (signed-in shopper, deposits
+     * and online deposits on, a method allowed for deposits, an amount below the
+     * balance and at least the minimum), except that an OFFLINE method is
+     * refused `PAYMENT_METHOD_UNUSABLE_HERE` (pay it with `payDeposit`), a method
+     * that does not apply to this order is `PAYMENT_METHOD_NOT_FOUND`, and
+     * `redirectUrl` must be on one of the store's own sites
+     * (`REDIRECT_URL_NOT_ALLOWED`, checked first).
+     *
+     * Keyed like `payDeposit`: one key per payment attempt, and a double-tap or a
+     * retry under it answers the SAME checkout rather than opening a second
+     * payment.
+     */
+    createDepositPaymentIntent(input: Shop.DepositPaymentIntentInput, options?: RequestOptions & {
+        idempotencyKey?: string;
+    }): Promise<Shop.CreateDepositPaymentIntentMutation['createDepositPaymentIntent']>;
     createStripePaymentIntent(options?: RequestOptions): Promise<StripePaymentIntentResult>;
-    getMolliePaymentMethods(input: MolliePaymentMethodsInput, options?: RequestOptions): Promise<MolliePaymentMethod[]>;
+    getMolliePaymentMethods(input: Shop.MolliePaymentMethodsInput, options?: RequestOptions): Promise<Shop.MolliePaymentMethodsQuery['molliePaymentMethods']>;
     /**
      * Mollie payment methods for the given PaymentMethod, ordered per the
      * channel's saved configuration and with hidden methods removed. Use this
@@ -3229,168 +1715,289 @@ export interface CommerceModule {
      * the merchant's curated order + visibility. Returns `[]` when no Mollie API
      * key is configured for the channel or Mollie is unreachable.
      */
-    getOrderedMolliePaymentMethods(paymentMethodCode: string, options?: RequestOptions): Promise<OrderedMollieMethod[]>;
-    createMolliePaymentIntent(input: CreateMolliePaymentIntentInput, options?: RequestOptions): Promise<MolliePaymentIntentResult>;
+    getOrderedMolliePaymentMethods(paymentMethodCode: string, options?: RequestOptions): Promise<Shop.OrderedMolliePaymentMethodsQuery['orderedMolliePaymentMethods']>;
+    createMolliePaymentIntent(input: Shop.MolliePaymentIntentInput, options?: RequestOptions): Promise<MolliePaymentIntentResult>;
     /**
      * Force-fetch the Mollie payment status and reconcile the order state.
      * Use as a fallback when the Mollie webhook is delayed or did not arrive
      * (e.g. local/staging without a public tunnel). Returns `null` when no
      * order matches `orderCode`.
      */
-    syncMolliePaymentStatus(orderCode: string, options?: RequestOptions): Promise<MollieOrderStatusResult | null>;
+    syncMolliePaymentStatus(orderCode: string, options?: RequestOptions): Promise<Shop.SyncMolliePaymentStatusMutation['syncMolliePaymentStatus']>;
+    /**
+     * Orders the store is currently HOLDING for the signed-in shopper.
+     *
+     * A held order is NOT the active order — {@link CommerceModule.getActiveOrder}
+     * returns a fresh cart while one is held, so the hold never blocks shopping,
+     * and that is exactly why a storefront has to ask for these separately.
+     * Empty for an anonymous visitor rather than an error.
+     *
+     * An order the store is REVIEWING after the shopper paid it (an app the store
+     * uses could not confirm it) is left out until the store accepts it: nothing
+     * can be paid on it before then.
+     */
+    getParkedOrders(options?: RequestOptions): Promise<Shop.ParkedOrderFragment[]>;
+    /**
+     * Pay some or all of what a held order still owes. Requires a signed-in
+     * customer, and the order must be theirs.
+     *
+     * The order does NOT leave its hold to take the payment: the money lands
+     * where it stands, and the order is settled (keeping the stock the store
+     * reserved for it) only once it is really PAID. Read the result's `settled` to
+     * tell a closed balance from a further deposit — and note it is also `false`
+     * for a payment that is merely AUTHORIZED, which leaves the hold in place
+     * until the authorization settles.
+     *
+     * This is for methods the store takes OFFLINE (bank transfer, invoice). A
+     * card method is refused `PAYMENT_METHOD_UNUSABLE_HERE`; use
+     * {@link CommerceModule.createParkedOrderPaymentIntent} for a card.
+     *
+     * Pass `idempotencyKey` for anything a shopper can double-tap: a repeat under
+     * the same key returns the first payment instead of taking the money twice.
+     *
+     * `ORDER_HELD_FOR_REVIEW` means the store is reviewing the order after it
+     * was paid and has not accepted it yet: tell the shopper the store will be in
+     * touch. Once the store accepts it, it appears in
+     * {@link CommerceModule.getParkedOrders} and can be paid here.
+     */
+    payParkedOrder(orderCode: string, input: Shop.PayParkedOrderInput, options?: RequestOptions & {
+        idempotencyKey?: string;
+    }): Promise<Shop.PayParkedOrderMutation['payParkedOrder']>;
+    /**
+     * Open a CARD payment for one of the signed-in shopper's held orders, for the
+     * whole outstanding balance (or, where the store takes deposits, part of it),
+     * and send the shopper to the returned `url`.
+     *
+     * Nothing is paid by this call and the order does not change: the money is
+     * recorded on the order when the provider confirms it, and the order leaves
+     * its hold only once it is fully paid. After the shopper comes back to
+     * `redirectUrl`, read {@link CommerceModule.getParkedOrders} (or the order)
+     * to see where it stands — the provider's confirmation may lag the redirect
+     * by a few seconds.
+     *
+     * `redirectUrl` must be on one of the store's own sites. Pass
+     * `idempotencyKey` so a double-tap or a retry answers the SAME checkout
+     * rather than opening a second payment. `ORDER_HELD_FOR_REVIEW` is refused
+     * as for {@link CommerceModule.payParkedOrder}.
+     */
+    createParkedOrderPaymentIntent(orderCode: string, input: Shop.ParkedOrderPaymentIntentInput, options?: RequestOptions & {
+        idempotencyKey?: string;
+    }): Promise<Shop.CreateParkedOrderPaymentIntentMutation['createParkedOrderPaymentIntent']>;
     login(email: string, password: string): Promise<LoginResult>;
-    register(input: RegisterInput): Promise<{
+    /**
+     * Sign in through a named authentication strategy — the general form of
+     * {@link CommerceModule.login}. `strategy` is a member of the engine's
+     * `AuthenticationInput` (`native` today, taking `{ username, password }`).
+     * The session token is captured like login's (`onAuthToken` fires).
+     *
+     * Every refusal throws `MutationError`: `errorCode` is the result type
+     * (`INVALID_CREDENTIALS_ERROR`, `NOT_VERIFIED_ERROR`), and `error.code`
+     * carries the strategy's reason when it gave one — the native strategy
+     * answers `PASSWORD_RESET_REQUIRED` (an imported account with no password;
+     * a set-password email is on its way) and `ACCOUNT_NOT_VERIFIED`. Branch on
+     * `error.code` before telling a shopper their password is wrong; `login`
+     * does that branching for the native strategy.
+     *
+     * `rememberMe` only lengthens a COOKIE session; the SDK sends bearer tokens,
+     * whose lifetime the engine's session duration decides. A blank `strategy`
+     * or an `input` that is not an object throws a 400 `INVALID_ARGUMENT` before
+     * any request.
+     */
+    authenticate<S extends AuthenticationStrategy>(strategy: S, input: AuthenticationStrategyInput<S>, options?: RequestOptions & {
+        rememberMe?: boolean;
+    }): Promise<Shop.CurrentUserFragment>;
+    register(input: Shop.RegisterCustomerInput): Promise<{
         success: boolean;
     }>;
     logout(): Promise<void>;
-    getCurrentCustomer(): Promise<Customer | null>;
+    getCurrentCustomer(): Promise<Shop.MeQuery['activeCustomer']>;
     /**
      * Price lists currently applying to the signed-in customer (identity only,
      * sorted by resolution priority). Empty for anonymous visitors with no
      * channel-wide lists.
      */
-    getActiveCustomerPriceLists(options?: RequestOptions): Promise<CustomerPriceList[]>;
-    getCustomerOrders(options?: OrderListOptions): Promise<PaginatedList<OrderSummary>>;
+    getActiveCustomerPriceLists(options?: RequestOptions): Promise<Shop.ActiveCustomerPriceListsQuery['activeCustomerPriceLists']>;
+    /**
+     * The signed-in customer's placed orders, newest first: the order-history rows
+     * with each line's `backorderedQuantity` and every parcel's barcode
+     * (`fulfillments[].trackingCodes`). An empty page for an anonymous visitor.
+     */
+    getCustomerOrders(options?: OrderListOptions): Promise<MergedSelection<NonNullable<Shop.CustomerOrdersQuery['activeCustomer']>['orders']>>;
     /**
      * Add every line of a previous order to the active cart. Returns the new
      * active order plus a list of lines that could not be added (e.g. variant
      * removed, out of stock).
      */
     reorder(orderCode: string): Promise<ReorderResult>;
-    getCollections(listOptions?: CollectionListOptions, options?: RequestOptions): Promise<Collection[]>;
-    getCollection(slug: string, options?: RequestOptions): Promise<CollectionDetail>;
+    getCollections(listOptions?: CollectionListOptions, options?: RequestOptions): Promise<Shop.CollectionFragment[]>;
+    /**
+     * A collection by slug. `{ metafields: true }` (or `{ metafields: {
+     * namespace } }`) also returns its storefront-visible metafields; it needs an
+     * engine serving `Collection.metafields`.
+     */
+    getCollection(slug: string, options: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields: true | {
+            namespace: string;
+        };
+    }): Promise<import('./commerce/products.js').CollectionWithMetafields>;
+    getCollection(slug: string, options?: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields?: false;
+    }): Promise<Shop.CollectionDetailFragment>;
+    getCollection(slug: string, options?: import('./commerce/products.js').CatalogDetailOptions): Promise<Shop.CollectionDetailFragment | import('./commerce/products.js').CollectionWithMetafields>;
     /**
      * A collection by id — typically `route.id` from the routes manifest. Tagged
      * `collection:<id>`; throws a `NOT_FOUND` StorefrontError (404) when absent.
+     * `{ metafields }` as for {@link CommerceModule.getCollection}.
      */
-    getCollectionById(id: string, options?: RequestOptions): Promise<CollectionDetail>;
-    updateCustomer(input: UpdateCustomerInput): Promise<Customer>;
+    getCollectionById(id: string, options: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields: true | {
+            namespace: string;
+        };
+    }): Promise<import('./commerce/products.js').CollectionWithMetafields>;
+    getCollectionById(id: string, options?: import('./commerce/products.js').CatalogDetailOptions & {
+        metafields?: false;
+    }): Promise<Shop.CollectionDetailFragment>;
+    getCollectionById(id: string, options?: import('./commerce/products.js').CatalogDetailOptions): Promise<Shop.CollectionDetailFragment | import('./commerce/products.js').CollectionWithMetafields>;
+    /** Resolves to the profile fields the mutation selects back — not the whole customer. */
+    updateCustomer(input: Shop.UpdateCustomerInput): Promise<Shop.UpdateCustomerMutation['updateCustomer']>;
     updatePassword(currentPassword: string, newPassword: string): Promise<void>;
+    /**
+     * Set the signed-in customer's FIRST password (an account that signs in by
+     * email link or code has none, so `updatePassword` cannot serve it). Throws
+     * `MutationError` `PASSWORD_ALREADY_SET_ERROR` once one exists,
+     * `PASSWORD_VALIDATION_ERROR` (reason in `fields.validationErrorMessage`),
+     * `NATIVE_AUTH_STRATEGY_ERROR`, or `SET_PASSWORD_REQUIRES_EMAIL_SIGN_IN_ERROR`
+     * when the session did not sign in to this store by email link or code. The
+     * account is emailed a notice.
+     */
+    setPassword(newPassword: string): Promise<void>;
     requestPasswordReset(emailAddress: string): Promise<void>;
-    resetPassword(token: string, password: string): Promise<{
-        id: string;
-        identifier: string;
-    }>;
+    resetPassword(token: string, password: string): Promise<Shop.CurrentUserFragment>;
     requestEmailUpdate(password: string, newEmailAddress: string): Promise<void>;
     updateEmail(token: string): Promise<void>;
-    verifyAccount(token: string, password?: string): Promise<{
-        id: string;
-        identifier: string;
-    }>;
+    verifyAccount(token: string, password?: string): Promise<Shop.CurrentUserFragment>;
     refreshVerification(emailAddress: string): Promise<void>;
-    requestMagicLink(emailAddress: string): Promise<void>;
-    loginWithMagicLink(token: string): Promise<{
-        id: string;
-        identifier: string;
-    }>;
-    loginWithMagicCode(emailAddress: string, code: string): Promise<{
-        id: string;
-        identifier: string;
-    }>;
-    createAddress(input: AddressInput): Promise<CustomerAddress>;
-    updateAddress(input: UpdateAddressInput): Promise<CustomerAddress>;
+    /**
+     * Email a sign-in link and 6-digit code. Resolves whether or not an account
+     * exists (anti-enumeration). Throws a `MutationError`
+     * `MAGIC_LINK_RATE_LIMITED_ERROR` with `retryAfterSeconds` when the store's
+     * magic-link limiter refuses, and a `StorefrontError` with `statusCode` 429
+     * (`code: 'RATE_LIMITED'`, `retryAfterSeconds`) when the platform's
+     * credential limiter does. Neither reveals whether the account exists.
+     */
+    requestMagicLink(emailAddress: string, options?: RequestMagicLinkOptions): Promise<void>;
+    loginWithMagicLink(token: string): Promise<Shop.CurrentUserFragment>;
+    loginWithMagicCode(emailAddress: string, code: string): Promise<Shop.CurrentUserFragment>;
+    createAddress(input: Shop.CreateAddressInput): Promise<Shop.CreateAddressMutation['createCustomerAddress']>;
+    updateAddress(input: Shop.UpdateAddressInput): Promise<Shop.UpdateAddressMutation['updateCustomerAddress']>;
     deleteAddress(id: string): Promise<void>;
-    getAvailableCountries(): Promise<Country[]>;
-    getOrderByCode(code: string): Promise<Order>;
+    getAvailableCountries(): Promise<Shop.AvailableCountriesQuery['availableCountries']>;
+    /**
+     * One of the shopper's orders by code — the cart selection plus what a placed
+     * order carries: `lines[].backorderedQuantity`, `customFields.chargedParcelCount`,
+     * the fulfilments with every parcel's barcode, the external shipments and the
+     * payment and delivery terms frozen at acceptance. Throws a `NOT_FOUND`
+     * `StorefrontError` (404) when there is none.
+     */
+    getOrderByCode(code: string): Promise<MergedSelection<NonNullable<Shop.OrderByCodeQuery['orderByCode']>>>;
     /** Invoices for one of the signed-in customer's own orders. */
-    getMyOrderInvoices(orderCode: string): Promise<CustomerInvoice[]>;
+    getMyOrderInvoices(orderCode: string): Promise<Shop.MyOrderInvoicesQuery['myOrderInvoices']>;
     /** Download one of the signed-in customer's own invoices as a base64 PDF. */
-    getMyInvoicePdf(invoiceId: string): Promise<CustomerInvoicePdf>;
-    getActiveChannel(): Promise<ActiveChannel>;
-    getPropertyGroups(options?: RequestOptions): Promise<PropertyGroup[]>;
-    getProductProperties(productId: string, options?: RequestOptions): Promise<ProductPropertyGroupValues[]>;
+    getMyInvoicePdf(invoiceId: string): Promise<Shop.MyInvoicePdfQuery['myInvoicePdf']>;
+    /** A five-minute signed download link for one of the signed-in customer's own invoices. */
+    getMyInvoiceDownloadUrl(invoiceId: string): Promise<Shop.CreateInvoiceDownloadUrlMutation['createInvoiceDownloadUrl']>;
+    /**
+     * The retail credit notes of one of the signed-in customer's own orders, newest first. A
+     * credit account's accounts-receivable credit notes are not listed.
+     */
+    getMyOrderCreditNotes(orderCode: string): Promise<Shop.MyOrderCreditNotesQuery['myOrderCreditNotes']>;
+    /** A five-minute signed download link for one of the signed-in customer's own credit notes. */
+    getMyCreditNoteDownloadUrl(creditNoteId: string): Promise<Shop.CreateCreditNoteDownloadUrlMutation['createCreditNoteDownloadUrl']>;
+    getActiveChannel(): Promise<Shop.ActiveChannelQuery['activeChannel']>;
+    getPropertyGroups(options?: RequestOptions): Promise<Shop.PropertyGroupFragment[]>;
+    getProductProperties(productId: string, options?: RequestOptions): Promise<Shop.ProductPropertyGroupValuesFragment[]>;
     /**
      * Flatten `getProductProperties(...)` output into a `slug → value` record for
      * the product-detail view. Pure helper — see `ProductPropertyRecord` for the
      * `content_item` (producer) caveat.
      */
-    mapProductProperties(groups: ProductPropertyGroupValues[]): ProductPropertyRecord;
-    getMySavedLists(): Promise<SavedList[]>;
-    getMySavedList(id: string): Promise<SavedList | null>;
-    createSavedList(name: string): Promise<SavedList>;
-    renameSavedList(id: string, name: string): Promise<SavedList>;
+    mapProductProperties(groups: Shop.ProductPropertyGroupValuesFragment[]): ProductPropertyRecord;
+    getMySavedLists(): Promise<Shop.SavedListFragment[]>;
+    getMySavedList(id: string): Promise<Shop.SavedListFragment | null>;
+    createSavedList(name: string): Promise<Shop.SavedListFragment>;
+    renameSavedList(id: string, name: string): Promise<Shop.SavedListFragment>;
     deleteSavedList(id: string): Promise<boolean>;
-    addItemToSavedList(listId: string, variantId: string, quantity: number): Promise<SavedList>;
-    updateSavedListItem(listId: string, variantId: string, quantity: number): Promise<SavedList>;
-    removeItemFromSavedList(listId: string, variantId: string): Promise<SavedList>;
+    addItemToSavedList(listId: string, variantId: string, quantity: number): Promise<Shop.SavedListFragment>;
+    updateSavedListItem(listId: string, variantId: string, quantity: number): Promise<Shop.SavedListFragment>;
+    removeItemFromSavedList(listId: string, variantId: string): Promise<Shop.SavedListFragment>;
     getFavoriteVariantIds(): Promise<string[]>;
-    getMyFavorites(options?: {
-        take?: number;
-        skip?: number;
-    }): Promise<PaginatedList<FavoriteItem>>;
+    getMyFavorites(options?: Shop.FavoriteListOptions): Promise<Shop.MyFavoritesQuery['myFavorites']>;
     toggleFavorite(productVariantId: string): Promise<boolean>;
     removeFavorite(productVariantId: string): Promise<boolean>;
     subscribeToStockNotification(productVariantId: string, emailAddress?: string): Promise<StockNotificationSubscriptionResult>;
     unsubscribeFromStockNotification(token: string): Promise<boolean>;
-    getProductRecommendations(productId: string, groupSlug?: string): Promise<RecommendedProductGroup[]>;
-    getAgeVerificationStatus(): Promise<AgeVerificationStatus>;
-    submitDateOfBirth(dateOfBirth: string): Promise<AgeVerificationStatus>;
-    confirmAge(): Promise<AgeVerificationStatus>;
-    getProductReviews(productId: string, options?: ReviewListOptions): Promise<{
-        items: ProductReview[];
-        totalItems: number;
-        nextCursor: string | null;
-    }>;
-    getRecentProductReviews(options?: RecentReviewsOptions): Promise<ProductReview[]>;
-    getReviewRatingSummary(productId: string): Promise<ReviewRatingSummary>;
-    getReviewAttributeAggregations(productId: string): Promise<ReviewAttributeAggregation[]>;
-    getReviewAttributes(productId?: string): Promise<ReviewAttribute[]>;
-    getMyReview(productId: string): Promise<ProductReview | null>;
-    getReviewChannelConfig(): Promise<ReviewChannelConfig>;
-    createReview(input: CreateReviewInput): Promise<CreateReviewResult>;
-    updateReview(id: string, input: UpdateReviewInput): Promise<ProductReview>;
+    getProductRecommendations(productId: string, groupSlug?: string): Promise<Shop.RecommendedProductGroupFragment[]>;
+    getAgeVerificationStatus(): Promise<Shop.AgeVerificationStatusQuery['ageVerificationStatus']>;
+    submitDateOfBirth(dateOfBirth: string): Promise<Shop.SubmitDateOfBirthMutation['submitDateOfBirth']>;
+    confirmAge(): Promise<Shop.ConfirmAgeMutation['confirmAge']>;
+    getProductReviews(productId: string, options?: Shop.ProductReviewListOptions): Promise<Shop.ProductReviewsQuery['productReviews']>;
+    getRecentProductReviews(options?: Shop.RecentReviewsOptions): Promise<Shop.ProductReviewFragment[]>;
+    getReviewRatingSummary(productId: string): Promise<Shop.ProductRatingSummaryQuery['productRatingSummary']>;
+    getReviewAttributeAggregations(productId: string): Promise<Shop.ProductReviewAttributeAggregationsQuery['productReviewAttributeAggregations']>;
+    getReviewAttributes(productId?: string): Promise<Shop.ReviewAttributesQuery['reviewAttributes']>;
+    getMyReview(productId: string): Promise<Shop.ProductReviewFragment | null>;
+    getReviewChannelConfig(): Promise<Shop.ReviewChannelConfigQuery['reviewChannelConfig']>;
+    createReview(input: Shop.CreateProductReviewInput): Promise<Shop.CreateProductReviewMutation['createProductReview']>;
+    updateReview(id: string, input: Shop.UpdateProductReviewInput): Promise<Shop.ProductReviewFragment>;
     deleteReview(id: string): Promise<boolean>;
     voteReview(reviewId: string, isHelpful: boolean): Promise<boolean>;
     reportReview(reviewId: string, reason: string): Promise<boolean>;
-    uploadReviewMedia(files: File[]): Promise<ReviewMediaUploadResult[]>;
-    getMySubscription(id: string): Promise<CustomerSubscription | null>;
+    uploadReviewMedia(files: File[]): Promise<Shop.UploadReviewMediaMutation['uploadReviewMedia']>;
+    getMySubscription(id: string): Promise<Shop.CustomerSubscriptionFragment | null>;
     previewSubscriptionPurchase(planId: string, options?: {
         provider?: 'mollie' | 'stripe';
         mandateId?: string;
-    }): Promise<SubscriptionPurchasePreview>;
-    startSubscriptionPurchase(input: SubscriptionPurchaseInput): Promise<SubscriptionPurchaseResult>;
-    getSubscriptionPurchaseStatus(id: string): Promise<SubscriptionPurchaseResult>;
-    previewMySubscriptionChange(id: string, input: SubscriptionLifecycleCommand): Promise<SubscriptionChangePreview>;
-    manageMySubscription(id: string, input: SubscriptionLifecycleCommand): Promise<CustomerSubscription>;
-    skipMySubscription(id: string, requestKey: string): Promise<CustomerSubscription>;
-    rescheduleMySubscription(id: string, date: string, requestKey: string): Promise<CustomerSubscription>;
-    undoMySubscriptionCancellation(id: string, requestKey: string): Promise<CustomerSubscription>;
+    }): Promise<Shop.SubscriptionPurchasePreviewQuery['subscriptionPurchasePreview']>;
+    startSubscriptionPurchase(input: SubscriptionPurchaseInput): Promise<Shop.SubscriptionPurchaseResultFragment>;
+    getSubscriptionPurchaseStatus(id: string): Promise<Shop.SubscriptionPurchaseResultFragment>;
+    previewMySubscriptionChange(id: string, input: SubscriptionLifecycleCommand): Promise<Shop.PreviewMySubscriptionChangeQuery['previewMySubscriptionChange']>;
+    manageMySubscription(id: string, input: SubscriptionLifecycleCommand): Promise<Shop.CustomerSubscriptionFragment>;
+    skipMySubscription(id: string, requestKey: string): Promise<Shop.CustomerSubscriptionFragment>;
+    rescheduleMySubscription(id: string, date: string, requestKey: string): Promise<Shop.CustomerSubscriptionFragment>;
+    undoMySubscriptionCancellation(id: string, requestKey: string): Promise<Shop.CustomerSubscriptionFragment>;
     replaceMySubscriptionMandate(id: string, input: SubscriptionPaymentActionInput & {
         provider: 'mollie' | 'stripe';
-    }): Promise<SubscriptionPurchaseResult>;
+    }): Promise<Shop.SubscriptionPurchaseResultFragment>;
     /**
      * A hosted link that pays the outstanding failed or charged-back cycle again,
      * without another delivery. Reuse `upcomingPayment.checkoutUrl` while it is live.
      */
-    recoverMySubscriptionPayment(id: string, input: SubscriptionPaymentActionInput): Promise<SubscriptionPurchaseResult>;
-    getMySubscriptions(): Promise<CustomerSubscription[]>;
+    recoverMySubscriptionPayment(id: string, input: SubscriptionPaymentActionInput): Promise<Shop.SubscriptionPurchaseResultFragment>;
+    getMySubscriptions(): Promise<Shop.CustomerSubscriptionFragment[]>;
     /**
      * Plans available to subscribe to in the current channel. Public —
      * works for anonymous visitors. Only enabled plans are returned.
      */
-    getSubscriptionPlans(): Promise<SubscriptionPlanPublic[]>;
+    getSubscriptionPlans(): Promise<Shop.SubscriptionPlanPublicFragment[]>;
     /**
      * The active customer's valid or still-pending payment mandates. Poll this
      * after `setupPaymentMandate` until the mandate flips to `valid`.
      */
-    getMyPaymentMandates(): Promise<MyPaymentMandate[]>;
+    getMyPaymentMandates(): Promise<Shop.MyPaymentMandateFragment[]>;
     /**
      * Begin establishing a payment mandate. Returns a `checkoutUrl` (Mollie) or
      * `clientSecret` (Stripe) for the frontend to complete the setup.
      */
-    setupPaymentMandate(input: {
-        provider: string;
-        redirectUrl: string;
-    }): Promise<SetupPaymentMandateResult>;
+    setupPaymentMandate(input: Shop.SetupPaymentMandateInput): Promise<Shop.SetupPaymentMandateMutation['setupPaymentMandate']>;
     /**
      * Create a subscription for the active customer against an enabled plan
      * using one of their valid mandates.
      */
-    createSubscription(planId: string, mandateId: string, requestKey?: string): Promise<CustomerSubscription>;
+    createSubscription(planId: string, mandateId: string, requestKey?: string): Promise<Shop.CustomerSubscriptionFragment>;
     /** Pause an active or trial subscription owned by the active customer. */
-    pauseMySubscription(id: string, reason?: string): Promise<CustomerSubscription>;
+    pauseMySubscription(id: string, reason?: string): Promise<Shop.CustomerSubscriptionFragment>;
     /** Resume a paused subscription owned by the active customer. */
-    resumeMySubscription(id: string): Promise<CustomerSubscription>;
+    resumeMySubscription(id: string): Promise<Shop.CustomerSubscriptionFragment>;
     /**
      * Cancel a subscription owned by the active customer. Defaults to
      * the earliest eligible cancellation date; minimum paid-cycle commitments still apply.
@@ -3398,65 +2005,78 @@ export interface CommerceModule {
     cancelMySubscription(id: string, options?: {
         reason?: string;
         immediate?: boolean;
-    }): Promise<CustomerSubscription>;
+    }): Promise<Shop.CustomerSubscriptionFragment>;
     /** Returns the active customer's quotes in the current channel. */
-    getMyQuotes(options?: QuoteListOptions): Promise<QuoteList>;
+    getMyQuotes(options?: Shop.QuoteListOptions): Promise<QuoteList>;
     /** Returns one of the active customer's quotes by id. */
     getMyQuote(id: string): Promise<Quote | null>;
     /**
      * Submits a new quote request. Lines are unpriced — a sales rep
      * prices them later. Requires the customer to belong to a configured
-     * B2B customer group.
+     * B2B customer group. The quote is in the currency this client prices in
+     * (`setOrderCurrency`, else the store's default; `Quote.currencyCode`).
      */
-    createQuoteRequest(input: CreateQuoteRequestInput): Promise<Quote>;
+    createQuoteRequest(input: Shop.CreateQuoteRequestInput): Promise<Quote>;
     /**
      * Accepts a priced+approved quote, producing a real `Order` in
-     * `ArrangingPayment` with the quoted unit prices applied.
-     */
-    acceptQuote(id: string): Promise<Order>;
+     * `ArrangingPayment` with the quoted unit prices applied, in the quote's
+     * currency. This client must be pricing in that currency
+     * (`Quote.currencyCode`; switch with `setOrderCurrency`), or the engine
+     * refuses it with `QUOTE_CURRENCY_MISMATCH` and creates nothing: the quoted
+     * prices are an agreement in the quote's currency and are never converted
+     * (engine released on or after 2026-10-01; an older engine created the order
+     * in the request's currency at the quoted figures).
+     */
+    acceptQuote(id: string): Promise<Shop.OrderFragment>;
     /** Cancels a quote owned by the active customer. */
     cancelMyQuote(id: string, reason?: string): Promise<Quote>;
     /**
      * Returns the active customer's returns (RMAs) in the current channel,
      * newest first. Requires an authenticated customer session.
      */
-    getMyReturns(options?: CustomerReturnListOptions): Promise<CustomerReturnList>;
+    getMyReturns(options?: CustomerReturnListOptions): Promise<Shop.MyReturnsQuery['myReturns']>;
     /**
      * Returns one of the active customer's returns by id, or `null` when it
      * does not exist or belongs to another customer.
      */
-    getMyReturn(id: string): Promise<CustomerReturn | null>;
+    getMyReturn(id: string): Promise<Shop.CustomerReturnFragment | null>;
     /**
      * Requests a return (RMA) for fulfilled lines of one of the active
      * customer's orders. Only allowed when the channel has returns enabled and
      * the order is inside the return window; quantities are capped at each
      * line's returnable quantity (see `getReturnableLinesForOrder`).
      */
-    requestReturn(input: RequestReturnInput): Promise<CustomerReturn>;
+    requestReturn(input: Shop.RequestReturnInput): Promise<Shop.CustomerReturnFragment>;
     /**
      * Cancels a return owned by the active customer. Only possible while the
      * return is still in the `requested` state.
      */
-    cancelMyReturn(id: string): Promise<CustomerReturn>;
+    cancelMyReturn(id: string): Promise<Shop.CustomerReturnFragment>;
     /**
      * Per-line returnable quantities and the return window for one of the
      * active customer's orders — drives the return-request UI. Lines only
      * appear once they have shipped/delivered quantity.
      */
-    getReturnableLinesForOrder(orderId: string): Promise<CustomerReturnEligibility>;
-    getMyVatValidationStatus(): Promise<VatValidationResult | null>;
-    setMyVatNumber(vatNumber: string): Promise<VatValidationResult>;
+    getReturnableLinesForOrder(orderId: string): Promise<Shop.ReturnableLinesForOrderQuery['returnableLinesForOrder']>;
+    getMyVatValidationStatus(): Promise<Shop.VatValidationResultFragment | null>;
+    setMyVatNumber(vatNumber: string): Promise<Shop.VatValidationResultFragment>;
     clearMyVatNumber(): Promise<boolean>;
-    getDropOffPoints(input: DropOffPointInput): Promise<DropOffPoint[]>;
-    getDeliveryOptions(input: DeliveryOptionsInput): Promise<DeliveryOption[]>;
+    getDropOffPoints(input: Shop.MyparcelDropOffPointInput): Promise<DropOffPoint[]>;
+    getDeliveryOptions(input: Shop.MyparcelDeliveryOptionsInput): Promise<DeliveryOption[]>;
     trackShipment(barcode: string, postalCode: string): Promise<ShipmentTrackingInfo | null>;
     /**
      * Carrier-agnostic pickup-location search. Currently MyParcel-backed;
      * future providers (Sendcloud, Hendriks) implement the same shape.
      */
-    findPickupLocations(input: PickupLocationSearchInput): Promise<PickupLocation[]>;
-    /** Persist the customer's chosen pickup location on the active order. */
-    selectPickupLocation(location: PickupLocation): Promise<Order>;
+    findPickupLocations(input: Shop.PickupLocationSearchInput): Promise<PickupLocation[]>;
+    /**
+     * Persist the customer's chosen pickup location on the active order. Resolves
+     * to the order's `__typename`, `id`, `code` and `state` — all the document
+     * selects; read the order again (`getActiveOrder`) to render it.
+     */
+    selectPickupLocation(location: PickupLocation): Promise<Extract<Shop.SetActiveOrderPickupLocationMutation['setActiveOrderPickupLocation'], {
+        __typename: 'Order';
+    }>>;
     /** Read the pickup location stored on the active order, or `null`. */
     getActivePickupLocation(): Promise<PickupLocation | null>;
     /**
@@ -3469,20 +2089,38 @@ export interface CommerceModule {
      * validation and at storefront runtime for footer/header/SEO rendering.
      */
     getBranding(options?: RequestOptions): Promise<BrandingInfo>;
+    /**
+     * The store's capability manifest as a storefront sees it: `{ ready }` per
+     * storefront-facing capability (`catalog`, `search`, `routes`, `menus`,
+     * `content_pages`, `checkout`, `branding`, `age_gate`, `reviews`,
+     * `subscriptions`). Branch on it before rendering a feature whose backing is
+     * optional. A key can be absent; treat that as not ready.
+     *
+     * Always the anonymous projection, even for a signed-in shopper: the
+     * shopper's session is never sent. Cached by the server for up to 60 s.
+     * `generated_at` is when the probes ran, not a freshness signal: an unchanged
+     * manifest answers 304 under conditional reads and keeps the first answer's
+     * timestamp.
+     */
+    getCapabilities(options?: RequestOptions): Promise<Plugins.PublicCapabilityManifestDto>;
 }
 export interface ContentModule {
-    resolvePath(path: string, locale?: string, options?: RequestOptions): Promise<ResolvedContent>;
+    resolvePath(path: string, locale?: string, options?: RequestOptions): Promise<Cms.PublicResolvedContentDto>;
     getContent(queryOptions: ContentQueryOptions, options?: RequestOptions): Promise<Record<string, unknown>>;
     /**
      * Typed channel-wide CMS content search. Pass `collectionId`/`collectionSlug`
      * to scope, or omit both to search across every collection.
      */
-    searchContent(query: ContentSearchQuery, options?: RequestOptions): Promise<ContentSearchResult>;
-    getAsset(id: string, options?: RequestOptions): Promise<CmsAsset>;
-    lookupAssets(ids: string[], options?: RequestOptions): Promise<CmsAsset[]>;
-    lookupVendureAssetDescriptions(vendureAssetIds: string[], options?: RequestOptions): Promise<Record<string, VendureAssetDescriptionTranslation[]>>;
-    /** Discover the channel's forms (public projection). See {@link FormSummary}. */
-    listForms(options?: FormListOptions & RequestOptions): Promise<FormListResult>;
+    searchContent(query: ContentSearchQuery, options?: RequestOptions): Promise<Cms.PublicCollectionItemSearchResultDto>;
+    getAsset(id: string, options?: RequestOptions): Promise<Cms.PublicAssetDto>;
+    lookupAssets(ids: string[], options?: RequestOptions): Promise<Cms.PublicAssetDto[]>;
+    lookupVendureAssetDescriptions(vendureAssetIds: string[], options?: RequestOptions): Promise<Record<string, Cms.PublicVendureAssetDescriptionDto[]>>;
+    /**
+     * Discover the channel's forms (public projection), with the list envelope
+     * as the CMS sends it. `fields` and `translations` are EMPTY on every form
+     * here — fetch one form (`getForm`/`getFormBySlug`) for them.
+     */
+    listForms(options?: FormListOptions & RequestOptions): Promise<Cms.PublicFormListResponseDto>;
     getForm(id: string, options?: RequestOptions): Promise<FormDefinition>;
     getFormBySlug(slug: string, options?: RequestOptions): Promise<FormDefinition>;
     /**
@@ -3490,7 +2128,7 @@ export interface ContentModule {
      * and its config/validation schema. Prefer the static {@link FORM_FIELD_TYPES}
      * constant when a round-trip isn't warranted.
      */
-    getFormFieldTypes(options?: RequestOptions): Promise<FormFieldTypeDescriptor[]>;
+    getFormFieldTypes(options?: RequestOptions): Promise<Cms.PublicFormFieldTypeDto[]>;
     /**
      * The same request as {@link ContentModule.getFormFieldTypes}, but keeping the
      * slug rules the response carries alongside the field types — use it when
@@ -3498,22 +2136,36 @@ export interface ContentModule {
      */
     getFormFieldTypeRegistry(options?: RequestOptions): Promise<FormFieldTypeRegistry>;
     submitForm(id: string, values: Record<string, unknown>, options?: RequestOptions): Promise<FormSubmissionResult>;
-    getContentStrings(format?: 'list' | 'export', options?: RequestOptions): Promise<ContentStrings>;
-    getMenus(options?: RequestOptions): Promise<Menu[]>;
+    /**
+     * Every content string of the channel. `'export'` (the default) is the map
+     * `key → language code → value` a page renders from; `'list'` is the CMS's
+     * paginated list envelope, one entity per string with its values.
+     */
+    getContentStrings(format: 'list', options?: RequestOptions): Promise<Cms.PublicContentStringListResponseDto>;
+    getContentStrings(format?: 'export', options?: RequestOptions): Promise<ContentStrings>;
+    getContentStrings(format?: 'list' | 'export', options?: RequestOptions): Promise<ContentStrings | Cms.PublicContentStringListResponseDto>;
+    /**
+     * One content string by id, with its value in every language. Throws a
+     * `VALIDATION_ERROR` before any request when `id` is not a UUID, and
+     * `NOT_FOUND` when the channel has no live string with that id. To render a
+     * page, `getContentStrings('export')` fetches every string in one request.
+     */
+    getContentString(id: string, options?: RequestOptions): Promise<Cms.PublicContentStringDto>;
+    getMenus(options?: RequestOptions): Promise<Cms.PublicMenuSummaryDto[]>;
     getMenu(slugOrId: string, options?: RequestOptions): Promise<Menu>;
-    getSitemap(languageCode?: string, options?: RequestOptions): Promise<SitemapEntry[]>;
-    lookupContentItems(ids: string[], options?: RequestOptions): Promise<ContentItemSummary[]>;
-    lookupContentItemsWithFields(ids: string[], fieldSlugs: string[], options?: RequestOptions): Promise<ContentItemWithFields[]>;
-    getCollectionPageValues(collectionId: string, languageCode?: string, options?: RequestOptions): Promise<CollectionPageValues>;
-    getCollections(options?: RequestOptions): Promise<CmsCollection[]>;
-    getCollection(collectionId: string, options?: RequestOptions): Promise<CmsCollectionDetail>;
+    getSitemap(languageCode?: string, options?: RequestOptions): Promise<Cms.PublicSitemapEntryDto[]>;
+    lookupContentItems(ids: string[], options?: RequestOptions): Promise<Cms.PublicItemSummaryDto[]>;
+    lookupContentItemsWithFields(ids: string[], fieldSlugs: string[], options?: RequestOptions): Promise<Cms.PublicItemWithFieldsDto[]>;
+    getCollectionPageValues(collectionId: string, languageCode?: string, options?: RequestOptions): Promise<Cms.PublicCollectionPageValuesDto>;
+    getCollections(options?: RequestOptions): Promise<Cms.PublicCollectionDto[]>;
+    getCollection(collectionId: string, options?: RequestOptions): Promise<Cms.PublicCollectionDetailDto>;
     getCollectionItems(collectionId: string, query?: CollectionItemsQuery, options?: RequestOptions): Promise<CmsCollectionItemList>;
-    getCollectionItem(collectionId: string, itemId: string, languageCode?: string, options?: RequestOptions): Promise<CmsCollectionItem>;
+    getCollectionItem(collectionId: string, itemId: string, languageCode?: string, options?: RequestOptions): Promise<Cms.PublicCollectionItemDetailDto>;
 }
 export interface NavigationModule {
-    getRoutes(languageCode?: string, options?: RequestOptions): Promise<RoutesResponse>;
+    getRoutes(languageCode?: string, options?: RequestOptions): Promise<Plugins.PublicRoutesResponseDto>;
     findRoute(path: string, languageCode?: string, options?: RequestOptions): Promise<ResolvedRoute | null>;
-    getRoutesByType(type: 'cms' | 'collection' | 'product', languageCode?: string, options?: RequestOptions): Promise<RouteEntry[]>;
+    getRoutesByType(type: Plugins.PublicRouteEntryDto['type'], languageCode?: string, options?: RequestOptions): Promise<Plugins.PublicRouteEntryDto[]>;
 }
 export interface PricingModule {
     /**
@@ -3526,7 +2178,7 @@ export interface PricingModule {
     readonly pricesIncludeTax: boolean;
     formatPrice(amount: number, currencyCode?: string, locale?: string): string;
     formatPriceRange(min: number, max: number, currencyCode?: string, locale?: string): string;
-    getTierForQuantity(tiers: PriceTier[], quantity: number): PriceTier | null;
+    getTierForQuantity(tiers: Shop.PriceTierFragment[], quantity: number): Shop.PriceTierFragment | null;
     computeTierTable(variant: VariantPriceData): TierTableEntry[];
     getPriceDisplay(variant: VariantPriceData): PriceDisplay;
     /**
@@ -3577,19 +2229,36 @@ export interface PricingModule {
      */
     parseTaxDisplayPolicy(fields: unknown): TaxDisplayPolicy;
     /**
-     * Pre-validate the cart against the channel's order minimums. Pass the object
-     * from `getOrderConstraints()` straight through. The server enforces at the
-     * `ArrangingPayment` transition regardless.
+     * Pre-validate the cart against the channel's order minimums. Pass the order
+     * and the object from `getOrderConstraints()` straight through. The server
+     * enforces at the `ArrangingPayment` transition regardless.
+     *
+     * It checks the figures the engine checks: the gross minimum against the
+     * lines' gross total (`subTotalWithTax`, no shipping), the net minimum and
+     * the delivery minimum (`fulfillmentMinOrderNet`, skipped for an exempt
+     * customer) against the lines' net total (`subTotal`), and the item count.
+     *
+     * Amounts are formatted in `constraints.currencyCode` and compared only with
+     * an order in that currency; when the two differ (constraints fetched before
+     * a currency switch, or no exchange rate on the engine) the amount checks are
+     * skipped and only the quantity is checked. Re-fetch the constraints after a
+     * currency switch.
      */
     validateOrderMinimums(order: {
         totalWithTax: number;
+        /**
+         * Gross total of the lines, minor units — the gross minimum's basis.
+         * Without it the check falls back to `totalWithTax`, which includes
+         * shipping and can call a cart valid that checkout refuses.
+         */
+        subTotalWithTax?: number;
         currencyCode: string;
         totalQuantity?: number;
         /**
          * Net (tax-exclusive) total, minor units — required for the
-         * `minOrderAmountNet` check. `subTotal` is preferred over `total` because
-         * the server compares line totals, which exclude shipping. Without one of
-         * them the net check is skipped.
+         * `minOrderAmountNet` and `fulfillmentMinOrderNet` checks. `subTotal` is
+         * preferred over `total` because the server compares line totals, which
+         * exclude shipping. Without one of them those checks are skipped.
          */
         subTotal?: number;
         total?: number;
@@ -3597,8 +2266,14 @@ export interface PricingModule {
         minOrderAmountGross?: number | null;
         minOrderAmountNet?: number | null;
         minOrderQuantity?: number | null;
+        /** The default delivery profile's NET minimum, as returned by `getOrderConstraints()`. */
+        fulfillmentMinOrderNet?: number | null;
+        /** True skips the delivery minimum, as the engine does for an exempt customer. */
+        customerIsExempt?: boolean | null;
         /** @deprecated Use `minOrderAmountGross`. */
         minOrderAmount?: number | null;
+        /** The currency the amounts are in, as returned by `getOrderConstraints()`. */
+        currencyCode?: string | null;
     }): OrderValidationResult;
     /**
      * The quantity ceiling for a variant: `max(0, saleable) + backorderAllowance`,
@@ -3648,7 +2323,7 @@ export interface OrderableStockInput {
      * state means "nothing in force", which is what every variant reported
      * before pre-orders existed.
      */
-    availability?: ProductAvailability | null;
+    availability?: Shop.ProductAvailabilityFragment | null;
     /**
      * Vendure's coarse display string (`'IN_STOCK'` / `'OUT_OF_STOCK'`). Selected
      * by every VARIANT document, where it is present even when `saleable` is
@@ -3678,16 +2353,20 @@ export interface MediaModule {
     getResponsiveImageData(asset: Asset, presets?: PresetName[]): ResponsiveImageData;
 }
 export interface CurrencyModule {
-    getExchangeRates(): Promise<ExchangeRate[]>;
+    getExchangeRates(): Promise<Shop.ExchangeRatesQuery['exchangeRates']>;
     /** Current rate for a single base→target pair, or `null` when unknown. */
-    getExchangeRate(targetCurrency: string): Promise<ExchangeRate | null>;
-    convertCurrency(amount: string, fromCurrency: string, toCurrency: string): Promise<ConvertedAmount>;
-    /** Convert from the base currency (EUR) to a target currency. */
-    convertFromBase(amount: string, targetCurrency: string): Promise<ConvertedAmount>;
-    /** Convert from a source currency to the base currency (EUR). */
-    convertToBase(amount: string, sourceCurrency: string): Promise<ConvertedAmount>;
+    getExchangeRate(targetCurrency: string): Promise<Shop.ExchangeRateQuery['exchangeRate']>;
+    /**
+     * `null` is the schema's (the field is nullable): today the engine answers a
+     * currency it has no rate for with an error, which this throws.
+     */
+    convertCurrency(amount: string, fromCurrency: string, toCurrency: string): Promise<Shop.ConvertedAmountFragment | null>;
+    /** Convert from the base currency (EUR) to a target currency (`null`: see `convertCurrency`). */
+    convertFromBase(amount: string, targetCurrency: string): Promise<Shop.ConvertedAmountFragment | null>;
+    /** Convert from a source currency to the base currency (EUR) (`null`: see `convertCurrency`). */
+    convertToBase(amount: string, sourceCurrency: string): Promise<Shop.ConvertedAmountFragment | null>;
     /** Convert one amount into several currencies in a single roundtrip. */
-    convertToMultiple(amount: string, fromCurrency: string, toCurrencies: string[]): Promise<BulkConversionResult[]>;
+    convertToMultiple(amount: string, fromCurrency: string, toCurrencies: string[]): Promise<Shop.ConvertToMultipleQuery['convertToMultiple']>;
 }
 export interface CreditModule {
     /**
@@ -3695,13 +2374,19 @@ export interface CreditModule {
      * channel, or `null` when not signed in, no credit account exists, or the
      * channel has B2B credit disabled. Soft-enforcement only — display the
      * `overLimit` / `hasOverdue` flags as warnings; the SDK never blocks checkout.
+     * Format the figures with `status.currencyCode`, not the session currency.
+     * Refused with code `EXCHANGE_RATE_UNAVAILABLE` when the customer has a credit
+     * limit and owes money in a currency the store has no exchange rate for: the
+     * exposure cannot be measured against the limit, so treat the status as
+     * unavailable, never as 0. Without a limit such money is left out of the
+     * figures instead.
      */
     getCreditStatus(options?: RequestOptions): Promise<B2bCreditStatus | null>;
     /**
      * Returns the signed-in customer's source-aware payment terms (including local B2B terms), or
      * `null` when the customer is not signed in or has no payment-terms account in this channel.
      */
-    getPaymentTerms(options?: RequestOptions): Promise<CustomerPaymentTerms | null>;
+    getPaymentTerms(options?: RequestOptions): Promise<Shop.CustomerPaymentTermsFragment | null>;
 }
 export interface StorefrontClient {
     readonly context: StoreContext;
@@ -3715,6 +2400,7 @@ export interface StorefrontClient {
     readonly seo: import('./seo/types.js').SeoModule;
     /** Platform-managed URL redirects for this channel. */
     readonly redirects: import('./redirects/types.js').RedirectStore;
+    readonly feeds: import('./feeds/types.js').FeedsModule;
     readonly maintenanceMode: boolean;
     setLanguage(code: string): void;
     getLanguage(): string;
@@ -3728,6 +2414,24 @@ export interface StorefrontClient {
     setOrderScope(scope: OrderScope | null): void;
     /** The scope currently sent as `x-order-scope`, or `null` when none is set. */
     getOrderScope(): OrderScope | null;
+    /**
+     * Send a raw Shop API document and return its `data`.
+     *
+     * @deprecated Call the typed methods instead; this keeps working until 1.0 and announces
+     * itself once per process (`onDeprecation` routes or silences that). The common uses all
+     * have a method now: a collection or product by id → `commerce.getCollectionById(id)` /
+     * `commerce.getProductById(id)`; storefront metafields → `commerce.getProduct(slug, {
+     * metafields: true })` (also on `getProductById`, `getCollection`, `getCollectionById`); the
+     * session currency → `createStorefrontClient({ currencyCode })` and
+     * `commerce.setOrderCurrency(code)`; what the store is ready to serve →
+     * `commerce.getCapabilities()`; one content string → `content.getContentString(id)`; logo,
+     * cover and favicon → `commerce.getBranding()`, a CMS asset → `content.getAsset(id)`; sign-in
+     * with a named strategy, order custom fields, unsetting addresses and order-state moves →
+     * `commerce.authenticate`, `setOrderCustomFields`, `unsetShippingAddress` /
+     * `unsetBillingAddress`, `getNextOrderStates` / `transitionOrder`. The Shop API fields no
+     * method sends yet are listed in the MCP capability catalog
+     * (`storefront://capability-catalog`).
+     */
     graphql<T = unknown>(query: string, variables?: Record<string, unknown>): Promise<T>;
 }
 //# sourceMappingURL=types.d.ts.map