@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/catalog/variants.js

@@ -1,9 +1,14 @@
 import { NotFoundError, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
-import { ASSET_REF_FIELDS, assertDeleted, availabilityCustomFields, DELETION_FIELDS, FACET_VALUE_REF_FIELDS, fieldOf, vendureListPage, } from './types.js';
+import { ASSET_REF_FIELDS, assertDeleted, availabilityCustomFields, DELETION_FIELDS, FACET_VALUE_REF_FIELDS, fieldOf, MAX_PAGE_SIZE, toAssetRef, vendureListPage, } from './types.js';
+import { findVariants } from './variant-find.js';
 const PARCEL_PACKING_MODES = ['shared', 'separate', 'none'];
 /** The engine's bounds for `parcelCapacity` (shipping-calculator's `MAX_PARCEL_CAPACITY`). */
 const PARCEL_CAPACITY_MIN = 1;
 const PARCEL_CAPACITY_MAX = 10_000;
+/** The variants {@link VariantsModule.optionSets} reads at most by default. */
+export const DEFAULT_OPTION_SET_LIMIT = MAX_PAGE_SIZE;
+/** The most variants one {@link VariantsModule.optionSets} call reads. */
+export const MAX_OPTION_SET_LIMIT = 100_000;
 /** The engine's bound on one `revertPrice` call (`MAX_REVERT_VARIANTS`). */
 export const MAX_REVERT_PRICE_VARIANTS = 500;
 export const VARIANT_FIELDS = /* GraphQL */ `
@@ -15,9 +20,16 @@ export const VARIANT_FIELDS = /* GraphQL */ `
   name
   sku
   enabled
-  price
-  priceWithTax
-  currencyCode
+  storePrice {
+    price
+    priceWithTax
+    currencyCode
+  }
+  prices {
+    currencyCode
+    price
+  }
+  stockOnHand
   taxCategory {
     id
     name
@@ -51,6 +63,18 @@ export const VARIANT_FIELDS = /* GraphQL */ `
     preorderLimit
     parcelCapacity
     parcelPacking
+    minOrderQuantity
+    salesUnit
+    position
+    cost
+    packageWeightGrams
+    packageLengthCm
+    packageWidthCm
+    packageHeightCm
+    backorderPolicy
+    backorderLimit
+    gtin
+    mpn
   }
 `;
 export const VARIANTS_QUERY = /* GraphQL */ `
@@ -61,6 +85,20 @@ export const VARIANTS_QUERY = /* GraphQL */ `
     }
   }
 `;
+/** Two fields a row, for {@link VariantsModule.optionSets}: the id and its options' ids. */
+export const VARIANT_OPTION_SETS_QUERY = /* GraphQL */ `
+  query CatalogVariantOptionSets($productId: ID!, $options: ProductVariantListOptions) {
+    productVariants(productId: $productId, options: $options) {
+      items {
+        id
+        options {
+          id
+        }
+      }
+      totalItems
+    }
+  }
+`;
 export const VARIANT_QUERY = /* GraphQL */ `
   query CatalogVariant($id: ID!) {
     productVariant(id: $id) { ${VARIANT_FIELDS} }
@@ -112,13 +150,33 @@ export const PRICE_BASIS_QUERY = /* GraphQL */ `
     }
   }
 `;
+/** The variant fields read out of `customFields` as they are, null for an unset one. */
+export const LIFTED_CUSTOM_FIELDS = [
+    'minOrderQuantity',
+    'salesUnit',
+    'position',
+    'cost',
+    'packageWeightGrams',
+    'packageLengthCm',
+    'packageWidthCm',
+    'packageHeightCm',
+    'backorderPolicy',
+    'backorderLimit',
+    'gtin',
+    'mpn',
+];
 function isParcelPacking(value) {
     return PARCEL_PACKING_MODES.includes(value);
 }
+/** Lift the custom fields to first-class fields. */
 export function toVariant(wire) {
-    const { customFields, ...rest } = wire;
+    const { customFields, featuredAsset, assets, ...rest } = wire;
+    const lifted = Object.fromEntries(LIFTED_CUSTOM_FIELDS.map((key) => [key, customFields?.[key] ?? null]));
     return {
         ...rest,
+        ...lifted,
+        featuredAsset: featuredAsset ? toAssetRef(featuredAsset) : null,
+        assets: assets.map(toAssetRef),
         taxClassKey: customFields?.taxClassKey ?? null,
         availabilityState: customFields?.availabilityState ?? 'inherit',
         availableFrom: customFields?.availableFrom ?? null,
@@ -144,13 +202,30 @@ function assertParcelRule(input) {
     }
 }
 function toWireInput(input) {
-    const { availabilityState, availableFrom, preorderLimit, taxClassKey, parcelCapacity, parcelPacking, priceBasis, ...rest } = input;
+    const { availabilityState, availableFrom, preorderLimit, taxClassKey, parcelCapacity, parcelPacking, priceBasis, minOrderQuantity, salesUnit, cost, packageWeightGrams, packageLengthCm, packageWidthCm, packageHeightCm, backorderPolicy, backorderLimit, gtin, mpn, ...rest } = input;
     void priceBasis;
     const customFields = availabilityCustomFields({
         availabilityState,
         availableFrom,
         preorderLimit,
     });
+    const fields = {
+        minOrderQuantity,
+        salesUnit,
+        cost,
+        packageWeightGrams,
+        packageLengthCm,
+        packageWidthCm,
+        packageHeightCm,
+        backorderPolicy,
+        backorderLimit,
+        gtin,
+        mpn,
+    };
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined)
+            customFields[key] = value;
+    }
     if (taxClassKey !== undefined)
         customFields.taxClassKey = taxClassKey;
     if (parcelCapacity !== undefined)
@@ -163,6 +238,69 @@ function toWireInput(input) {
 function refuse(code, message) {
     return new ValidationError({ code, message, status: 400, service: 'vendure' });
 }
+const VARIANT_SORT_FIELDS = [
+    'position',
+    'name',
+    'sku',
+    'createdAt',
+    'updatedAt',
+];
+/**
+ * The engine's `ProductVariantListOptions` for {@link VariantListOptions}, without the page
+ * window. ONE sort key, never a tie-breaker beside it: graphql-js coerces an input object in the
+ * order its TYPE declares the fields, and `ProductVariantSortParameter` declares `id` before every
+ * field named here, so `{ position, id }` reaches the engine as `{ id, position }` and sorts by id
+ * alone (W10-113 finding). The engine completes the order itself: `productVariants(productId:)`
+ * (core's `getVariantsByProductId`) appends `id ASC` after the caller's key, which makes it total,
+ * so offset pages neither repeat nor skip a row even where `position` is null.
+ */
+export function variantListOptions(options) {
+    const sort = options?.sort ?? { field: 'position', direction: 'ASC' };
+    if (!VARIANT_SORT_FIELDS.includes(sort.field) ||
+        (sort.direction !== 'ASC' && sort.direction !== 'DESC')) {
+        throw refuse('INVALID_VARIANT_SORT', `sort must name one of ${VARIANT_SORT_FIELDS.join(', ')} and the direction ASC or DESC; got ${JSON.stringify(sort)}. Nothing was sent.`);
+    }
+    const term = options?.term?.trim() ?? '';
+    return {
+        sort: { [sort.field]: sort.direction },
+        // `filterOperator` joins the top-level fields, which are exactly these two.
+        ...(term === ''
+            ? {}
+            : {
+                filter: { sku: { contains: term }, name: { contains: term } },
+                filterOperator: 'OR',
+            }),
+    };
+}
+/**
+ * Every priced input (`price`, or any `prices` entry) must be whole minor units and state its
+ * basis, and the basis must be the store's. Read per call, with the call's own options, so a
+ * per-call tenant is checked against ITS store rather than the client's default one.
+ */
+export async function assertPricesStateBasis(transport, inputs, options) {
+    const priced = inputs.filter((input) => input.price !== undefined || input.prices !== undefined);
+    if (priced.length === 0)
+        return;
+    for (const input of priced) {
+        const amounts = [
+            ...(input.price !== undefined ? [input.price] : []),
+            ...(input.prices ?? []).map((entry) => entry.price),
+        ];
+        const fractional = amounts.find((amount) => !Number.isInteger(amount));
+        if (fractional !== undefined) {
+            throw refuse('INVALID_PRICE', `price must be a whole number of minor units; got ${String(fractional)}.`);
+        }
+        if (input.priceBasis !== 'net' && input.priceBasis !== 'gross') {
+            throw refuse('PRICE_BASIS_REQUIRED', 'A variant price must state its basis: priceBasis "net" or "gross".');
+        }
+    }
+    const channel = await fieldOf(transport, PRICE_BASIS_QUERY, 'activeChannel', {}, options);
+    const storeBasis = channel.pricesIncludeTax ? 'gross' : 'net';
+    const wrong = priced.find((input) => input.priceBasis !== storeBasis);
+    if (wrong) {
+        throw refuse('PRICE_BASIS_MISMATCH', `This store states prices ${storeBasis === 'gross' ? 'including' : 'excluding'} tax, so a price must be sent with priceBasis "${storeBasis}"; got "${String(wrong.priceBasis)}". Convert it before sending — the SDK does not, because the rate depends on each order's zone.`);
+    }
+}
 export function createVariantsModule(transport) {
     /**
      * Every priced input must state its basis, and the basis must be the store's.
@@ -170,23 +308,7 @@ export function createVariantsModule(transport) {
      * against ITS store rather than the client's default one.
      */
     const assertPriceBasis = async (inputs, options) => {
-        const priced = inputs.filter((input) => input.price !== undefined);
-        if (priced.length === 0)
-            return;
-        for (const input of priced) {
-            if (!Number.isInteger(input.price)) {
-                throw refuse('INVALID_PRICE', `price must be a whole number of minor units; got ${String(input.price)}.`);
-            }
-            if (input.priceBasis !== 'net' && input.priceBasis !== 'gross') {
-                throw refuse('PRICE_BASIS_REQUIRED', 'A variant price must state its basis: priceBasis "net" or "gross".');
-            }
-        }
-        const channel = await fieldOf(transport, PRICE_BASIS_QUERY, 'activeChannel', {}, options);
-        const storeBasis = channel.pricesIncludeTax ? 'gross' : 'net';
-        const wrong = priced.find((input) => input.priceBasis !== storeBasis);
-        if (wrong) {
-            throw refuse('PRICE_BASIS_MISMATCH', `This store states prices ${storeBasis === 'gross' ? 'including' : 'excluding'} tax, so a price must be sent with priceBasis "${storeBasis}"; got "${String(wrong.priceBasis)}". Convert it before sending — the SDK does not, because the rate depends on each order's zone.`);
-        }
+        await assertPricesStateBasis(transport, inputs, options);
     };
     const mapAll = (rows, what) => rows.map((row) => {
         if (row === null) {
@@ -209,13 +331,39 @@ export function createVariantsModule(transport) {
         return mapAll(rows, 'updateProductVariants');
     };
     return {
-        list(productId, options) {
-            return vendureListPage(transport, VARIANTS_QUERY, 'productVariants', (skip, take) => ({ productId, options: { skip, take } }), options, toVariant);
+        async list(productId, options) {
+            const listOptions = variantListOptions(options);
+            return vendureListPage(transport, VARIANTS_QUERY, 'productVariants', (skip, take) => ({ productId, options: { skip, take, ...listOptions } }), options, toVariant);
+        },
+        async optionSets(productId, options) {
+            const { limit = DEFAULT_OPTION_SET_LIMIT, ...call } = options ?? {};
+            if (!Number.isInteger(limit) || limit < 1 || limit > MAX_OPTION_SET_LIMIT) {
+                throw refuse('INVALID_OPTION_SET_LIMIT', `limit must be a whole number from 1 to ${String(MAX_OPTION_SET_LIMIT)}; got ${String(limit)}. Nothing was sent.`);
+            }
+            const combinations = [];
+            let totalItems = 0;
+            while (combinations.length < limit) {
+                const take = Math.min(MAX_PAGE_SIZE, limit - combinations.length);
+                const page = await fieldOf(transport, VARIANT_OPTION_SETS_QUERY, 'productVariants', 
+                // By id alone (unique, so no page repeats a row of another): one key, as above.
+                { productId, options: { skip: combinations.length, take, sort: { id: 'ASC' } } }, call);
+                totalItems = page.totalItems;
+                for (const item of page.items) {
+                    combinations.push(item.options.map((option) => option.id).sort());
+                }
+                // A short page is the end, whatever `totalItems` claims: never ask past it.
+                if (page.items.length < take || combinations.length >= totalItems)
+                    break;
+            }
+            return { combinations, totalItems, truncated: totalItems > combinations.length };
         },
         async get(id, options) {
             const variant = await fieldOf(transport, VARIANT_QUERY, 'productVariant', { id }, options);
             return variant ? toVariant(variant) : null;
         },
+        find(input, options) {
+            return findVariants(transport, input, options);
+        },
         async create(inputs, options) {
             inputs.forEach(assertParcelRule);
             await assertPriceBasis(inputs, options);

package/dist/catalog/visibility.d.ts

@@ -1,5 +1,6 @@
-import { type Transport } from '@sixtyninecommerce/core';
+import { type Page, type Transport } from '@sixtyninecommerce/core';
 import type { Call } from '../types.js';
+import { type Product, type ProductListOptions } from './products.js';
 export type ProductVisibilityMode = 'public' | 'private';
 /**
  * Who a product is shown to on the storefront. A product with no row is
@@ -29,12 +30,20 @@ export interface SetProductVisibilityInput {
  * `USER_INPUT_ERROR` (`ValidationError`): "Product {id} not found in this
  * channel". A write from here is always `source: manual`, which a later
  * pipeline import leaves alone.
- *
- * The Admin API's `productsByVisibility` list is deliberately NOT exposed: it
- * counts and pages visibility rows across every store before narrowing to this
- * one, so its totals and pages are wrong (recorded as a finding).
  */
 export interface VisibilityModule {
+    /**
+     * This store's products in one mode, with `products.list`'s filter, sort and
+     * paging (filtered before paging; `totalItems` counts this store only).
+     * `public` lists products with an explicit public row, not every product
+     * without one. With no sort, newest product first.
+     *
+     * Needs an engine whose `productsByVisibility` honours its options: an older
+     * one ignored all but the page and counted other stores' products, so it is
+     * refused before running (`ValidationError`, `GRAPHQL_VALIDATION_FAILED` or
+     * `BAD_REQUEST`) rather than answered with an unfiltered page.
+     */
+    list(mode: ProductVisibilityMode, options?: ProductListOptions): Promise<Page<Product>>;
     /** Null when the product has no override (it is public). `NotFoundError` for an unknown product. */
     get(productId: string, options?: Call): Promise<ProductVisibility | null>;
     set(input: SetProductVisibilityInput, options?: Call): Promise<ProductVisibility>;
@@ -51,6 +60,12 @@ export interface VisibilityModule {
     clear(productId: string, options?: Call): Promise<void>;
 }
 export declare const PRODUCT_VISIBILITY_QUERY = "\n  query CatalogProductVisibility($id: ID!) {\n    product(id: $id) {\n      id\n      visibility { \n  productId\n  mode\n  source\n  allowedCustomerGroupIds\n  createdAt\n  updatedAt\n }\n    }\n  }\n";
+/**
+ * The marker field is selected only so that an engine from before the list
+ * honoured its options refuses the document as an unknown field; nothing reads
+ * its answer. It must stay the SECOND root field.
+ */
+export declare const PRODUCTS_BY_VISIBILITY_QUERY = "\n  query CatalogProductsByVisibility($mode: ProductVisibilityMode!, $options: ProductListOptions) {\n    productsByVisibility(mode: $mode, options: $options) {\n      items { \n  id\n  \n  catalogueOwnership {\n    state\n    organizationName\n    editableHere\n  }\n\n  createdAt\n  updatedAt\n  languageCode\n  name\n  slug\n  description\n  enabled\n  featuredAsset { \n  id\n  name\n  preview\n  source\n  type\n  mimeType\n  customFields {\n    altText\n  }\n }\n  assets { \n  id\n  name\n  preview\n  source\n  type\n  mimeType\n  customFields {\n    altText\n  }\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  optionGroups {\n    id\n    code\n    name\n    customFields {\n      isShared\n    }\n    options {\n      id\n      code\n      name\n    }\n    translations {\n      id\n      languageCode\n      name\n    }\n  }\n  translations {\n    id\n    languageCode\n    name\n    slug\n    description\n  }\n  excludedFromStore\n  variantList(options: { take: 1 }) {\n    totalItems\n  }\n  customFields {\n    availabilityState\n    availableFrom\n    preorderLimit\n    brand\n    condition\n  }\n }\n      totalItems\n    }\n    productsByVisibilityHonoursListOptions\n  }\n";
 export declare const SET_VISIBILITY_MUTATION = "\n  mutation CatalogSetVisibility($input: SetProductVisibilityInput!) {\n    setProductVisibility(input: $input) { \n  productId\n  mode\n  source\n  allowedCustomerGroupIds\n  createdAt\n  updatedAt\n }\n  }\n";
 export declare const BULK_SET_VISIBILITY_MUTATION = "\n  mutation CatalogBulkSetVisibility($input: BulkSetProductVisibilityInput!) {\n    bulkSetProductVisibility(input: $input) {\n      updated\n    }\n  }\n";
 export declare const CLEAR_VISIBILITY_MUTATION = "\n  mutation CatalogClearVisibility($productId: ID!) {\n    clearProductVisibility(productId: $productId)\n  }\n";

package/dist/catalog/visibility.js

@@ -1,5 +1,6 @@
 import { NotFoundError } from '@sixtyninecommerce/core';
-import { fieldOf } from './types.js';
+import { PRODUCT_FIELDS, productListOptions, toProduct, } from './products.js';
+import { fieldOf, vendureListPage } from './types.js';
 const VISIBILITY_FIELDS = /* GraphQL */ `
   productId
   mode
@@ -16,6 +17,20 @@ export const PRODUCT_VISIBILITY_QUERY = /* GraphQL */ `
     }
   }
 `;
+/**
+ * The marker field is selected only so that an engine from before the list
+ * honoured its options refuses the document as an unknown field; nothing reads
+ * its answer. It must stay the SECOND root field.
+ */
+export const PRODUCTS_BY_VISIBILITY_QUERY = /* GraphQL */ `
+  query CatalogProductsByVisibility($mode: ProductVisibilityMode!, $options: ProductListOptions) {
+    productsByVisibility(mode: $mode, options: $options) {
+      items { ${PRODUCT_FIELDS} }
+      totalItems
+    }
+    productsByVisibilityHonoursListOptions
+  }
+`;
 export const SET_VISIBILITY_MUTATION = /* GraphQL */ `
   mutation CatalogSetVisibility($input: SetProductVisibilityInput!) {
     setProductVisibility(input: $input) { ${VISIBILITY_FIELDS} }
@@ -35,6 +50,9 @@ export const CLEAR_VISIBILITY_MUTATION = /* GraphQL */ `
 `;
 export function createVisibilityModule(transport) {
     return {
+        list(mode, options) {
+            return vendureListPage(transport, PRODUCTS_BY_VISIBILITY_QUERY, 'productsByVisibility', (skip, take) => ({ mode, options: productListOptions(options, skip, take) }), options, toProduct);
+        },
         async get(productId, options) {
             const product = await fieldOf(transport, PRODUCT_VISIBILITY_QUERY, 'product', { id: productId }, options);
             if (!product) {

package/dist/client.d.ts

@@ -10,47 +10,63 @@ import { type AuthModule } from './auth/index.js';
 import { type BulkModule } from './bulk/index.js';
 import { type CatalogModule } from './catalog/index.js';
 import { type ComplianceModule } from './compliance/index.js';
+import { type ContentAssetsModule } from './content/assets.js';
 import { type FormsModule } from './content/forms.js';
+import { type ContentItemsModule } from './content/items.js';
+import { type ContentFieldsModule, type ContentPageValuesModule, type ContentTypesModule } from './content/types.js';
 import { type CustomObjectsModule } from './custom-objects/index.js';
 import { type CustomersModule } from './customers/index.js';
 import { type DocumentsModule } from './documents/index.js';
 import { type EventsModule } from './events/index.js';
 import { type FeedsModule } from './feeds/index.js';
 import { type FulfillmentsModule } from './fulfillments/index.js';
+import { type GeoModule } from './geo/index.js';
 import { type HeadsModule } from './heads/index.js';
 import { type HooksModule } from './hooks/index.js';
+import { type IntegrationsModule } from './integrations/index.js';
 import { type JobsModule } from './jobs/index.js';
 import { type LocationsModule } from './locations/index.js';
 import { type MetaModule } from './meta/index.js';
 import { type MetafieldsModule } from './metafields/index.js';
 import { type OrdersModule } from './orders/index.js';
 import { type PaymentsModule } from './payments/index.js';
+import { type PickupsModule } from './pickups/index.js';
 import { type PlatformAppsModule } from './platform/apps.js';
 import { type PlatformCatalogModule } from './platform/catalog.js';
+import { type PlatformChannelsModule } from './platform/channels.js';
 import { type PlatformEntitlementsModule } from './platform/entitlements.js';
+import { type PlatformGeoModule } from './platform/geo.js';
 import { type PlatformLegalEntitiesModule } from './platform/legal-entities.js';
 import { type PlatformOrganizationsModule } from './platform/organizations.js';
 import { type PlatformModule } from './platform/provision-store.js';
 import { type PlatformReportsModule } from './platform/reports.js';
 import { type PlatformServerMetricsModule } from './platform/server-metrics.js';
+import { type PlatformTaxModule } from './platform/tax.js';
 import { type PosModule } from './pos/index.js';
 import { type PricingModule } from './pricing/index.js';
 import { type ProvenanceModule } from './provenance/index.js';
+import { type PurchasingModule } from './purchasing/index.js';
+import { type QuotesModule } from './quotes/index.js';
 import { type ReportsModule } from './reports/index.js';
+import { type ReturnsModule } from './returns/index.js';
+import { type SearchModule } from './search/index.js';
 import { type RedirectsModule } from './seo/redirects.js';
-import { type ParcelCountSuggestionMethod } from './shipping/parcel-count-suggestion.js';
-import { type ShippingModule } from './shipping/parcel-rule.js';
+import { type ShippingModule } from './shipping/index.js';
 import { type StockModule } from './stock/index.js';
 import { type StoredValueModule } from './stored-value/index.js';
+import { type SubscriptionsModule } from './subscriptions/index.js';
 import { type TaxModule } from './tax/index.js';
 import { type CapabilitiesModule } from './tenant/capabilities.js';
 import { type ChannelsModule } from './tenant/channels.js';
+import { type EmailStyleModule } from './tenant/email-style.js';
+import { type EmailTemplatesModule } from './tenant/email-templates.js';
 import { type TenantEntitlementsReader } from './tenant/entitlements.js';
 import { type FieldGroupOwnersReader, type FieldGroupSyncSourcesReader } from './tenant/field-groups.js';
 import { type LegalEntityModule } from './tenant/legal-entity.js';
 import { type NotificationsModule } from './tenant/notifications.js';
 import { type RetentionModule } from './tenant/retention.js';
 import { type SettingsSourcesModule } from './tenant/settings-sources.js';
+import { type TenantTimeZoneReader } from './tenant/time-zone.js';
 import { type UploadsModule } from './uploads/index.js';
 import { type UsersModule } from './users/index.js';
 export interface AdminClientConfig {
@@ -117,13 +133,23 @@ export interface AdminClient {
     };
     audit: AuditModule;
     /**
-     * Products, variants, options, facets, collections, assets, visibility and
-     * properties (spec §9.2 `catalog`). Needs the catalog permissions.
+     * Products, variants, options, facets, collections, assets, visibility,
+     * properties and recommendations (spec §9.2 `catalog`). Needs the catalog
+     * permissions.
      */
     catalog: CatalogModule;
     channels: ChannelsModule;
+    /**
+     * The CMS's content: forms, content types (collections) with their fields, each type's
+     * index-page values, the types' items, and the media library (spec §9.2 `content`).
+     */
     content: {
         forms: FormsModule;
+        types: ContentTypesModule;
+        fields: ContentFieldsModule;
+        pageValues: ContentPageValuesModule;
+        items: ContentItemsModule;
+        assets: ContentAssetsModule;
     };
     /**
      * Compliance requests to installed apps: data requests, customer and
@@ -141,6 +167,12 @@ export interface AdminClient {
      * the store's tax, payment or fulfillment provider; `ping` tests one hook.
      */
     hooks: HooksModule;
+    /**
+     * The store's connections to other systems (spec §9.2). `pipelines.drafts` keeps a
+     * half-finished import or export set-up on the server for 7 days after its last change, for any
+     * admin of the store with pipeline rights, and never holds a credential.
+     */
+    integrations: IntegrationsModule;
     /**
      * Platform events (spec §6.9): `poll`/`pollAll`/`replay`/`head` over the event log (a
      * machine credential with `ReadPlatformEvents`), `subscribe` to build a typed webhook
@@ -166,6 +198,11 @@ export interface AdminClient {
      * AI helpers. Channel-scoped throughout — no method takes a channel.
      */
     feeds: FeedsModule;
+    /**
+     * Countries and zones (spec §9.2, ruling G128): platform-wide reads, the same for every store.
+     * `mostSpecificZone` (exported beside it) answers the zone provisioning picks for a country.
+     */
+    geo: GeoModule;
     /** The store's head registry: every client surface it serves (spec §6.7). */
     heads: HeadsModule;
     /** Every long-running operation the platform runs, under one resource (spec §6.11). */
@@ -197,6 +234,12 @@ export interface AdminClient {
      * recorded against an order with what it stands at (spec §8.2).
      */
     payments: PaymentsModule;
+    /**
+     * Store pickup (click & collect, POS C1/33): the store's pickups, an order's pickup, and
+     * "ready". A location's pickup settings are `locations.pickup/setPickup`; the hand-over is the
+     * till's.
+     */
+    pickups: PickupsModule;
     /**
      * Point of sale on a machine principal (spec §8.8): register sessions, cash,
      * tenders, the sale, refunds, X and Z — with no paired tablet. Needs a `pos`
@@ -215,18 +258,54 @@ export interface AdminClient {
      * writer only; the history is the platform event log.
      */
     provenance: ProvenanceModule;
+    /**
+     * Buying stock from suppliers, per legal entity (purchase-orders spec §10.1): `settings` with
+     * its document `numbering`, `suppliers` with their `contacts`, `purchaseOrders` with their
+     * `lines`, `replenishment` (reorder rules and suggestions), and `cost` (a variant's cost
+     * ledger). Needs the Purchasing plugin on the store.
+     */
+    purchasing: PurchasingModule;
+    /**
+     * B2B quotes: list, read, build and price a quote, move it through its statuses, and convert an
+     * approved one into an order (keyed); its PDF, its email, the store's quote design and settings
+     * (headless W10-35a). `Quote.editable` / `convertible` are the engine's answer to "what can be
+     * done now".
+     */
+    quotes: QuotesModule;
     /** Tenant reporting in minor units and ISO-8601 UTC (spec §9.2 `reports`, §9.3). */
     reports: ReportsModule;
+    /**
+     * Subscription plans (list, read, create, update, products, delete, price breakdown) and the
+     * subscriptions sold on them (list, read, a customer's subscriptions and mandates, the store's
+     * billing readiness) (headless W10-36), and their lifecycle and billing commands: purchase,
+     * pause/resume/skip/reschedule, cancel, payment method replacement, recovery, reconciliation,
+     * renewal and settlement retries, attention clearing and price changes, each money command under
+     * one idempotency key per attempt (headless W10-114). Statuses are the meta catalog's lower-case
+     * words.
+     */
+    subscriptions: SubscriptionsModule;
+    /**
+     * Order returns (RMA): one return, an order's returns, what of an order can
+     * still be returned, and the plan for settling a return (headless W9-47). The
+     * list and the writes are phase 7.
+     */
+    returns: ReturnsModule;
+    /**
+     * One search across the store (spec §7 `search.entities`): products, orders, customers and
+     * content in one call, each type's best matches already loaded, in relevance order. A type
+     * the credential may not read is skipped and named, never refused.
+     */
+    search: SearchModule;
     seo: {
         redirects: RedirectsModule;
     };
     /**
      * Shipping of the ACTIVE channel (spec §9.2 `shipping`): the channel's
-     * `parcelRule`, and `parcelCountSuggestion` for a set of variant items.
+     * `parcelRule`, `parcelCountSuggestion` for a set of variant items, the
+     * C.J. Hendriks 3PL settings (`hendriks.config`) and the MyParcel set-up,
+     * carriers and parcel senders (`myparcel`).
      */
-    shipping: ShippingModule & {
-        parcelCountSuggestion: ParcelCountSuggestionMethod;
-    };
+    shipping: ShippingModule;
     /**
      * Stock per location by state, the ledger with reasons, reason-carrying
      * adjustments, transfers and allocation release (spec §9.2 `stock`, §8.7).
@@ -238,7 +317,10 @@ export interface AdminClient {
      * payment on an order.
      */
     storedValue: StoredValueModule;
-    /** The store's own tax classes and their per-country mappings (spec §8.6). */
+    /**
+     * The store's own tax classes and their per-country mappings (spec §8.6), and the platform-wide
+     * tax categories and rates they map onto.
+     */
     tax: TaxModule;
     /**
      * Signed direct-to-storage uploads (spec §6.11): reserve a place, PUT the
@@ -269,6 +351,10 @@ export interface AdminClient {
         retention: RetentionModule;
         /** Per notification event: on or off, who sends it (spec §8.15), and to whom. */
         notifications: NotificationsModule;
+        /** The look of the store's emails: colours, type, logo and layout (`settings.email`). */
+        emailStyle: EmailStyleModule;
+        /** The store's email templates, by type: previews rendered as the store would send them. */
+        emailTemplates: EmailTemplatesModule;
         /**
          * Where each settings group comes from — the store or its organization — and the store's
          * choice to keep its own values (multi-region spec §5.3).
@@ -279,6 +365,11 @@ export interface AdminClient {
          * Changing it needs `UpdateSeller` on every store of the entity.
          */
         legalEntity: LegalEntityModule;
+        /**
+         * The active store's IANA time zone as the engine resolves it (`Europe/Amsterdam` when unset
+         * or invalid): the zone the API counts calendar days in. Never the browser's.
+         */
+        timeZone: TenantTimeZoneReader;
     };
     /**
      * Human SuperAdmin surface. Every method refuses an API token or an app
@@ -289,11 +380,22 @@ export interface AdminClient {
         apps: PlatformAppsModule;
         /** Catalogue maintenance on a named store (the translation-language repair). */
         catalog: PlatformCatalogModule;
+        /**
+         * The codes renames hold against reuse, and their release: a release that must clear files
+         * first is finished by the engine itself — see {@link PlatformChannelsModule}.
+         */
+        channels: PlatformChannelsModule;
         /**
          * Which external plugins each store may use: read one store's grants or every store's, and
          * connect or disconnect a plugin for a store — see {@link PlatformEntitlementsModule}.
          */
         entitlements: PlatformEntitlementsModule;
+        /**
+         * The platform's zones and countries every store shares: create, rename, delete and change
+         * the members of a zone; switch a country on or off — see {@link PlatformGeoModule}. Reads
+         * are `geo`.
+         */
+        geo: PlatformGeoModule;
         /**
          * The platform's legal entities (multi-region spec §7.1): SuperAdmin list and create; read and
          * update through every store of an entity — see {@link PlatformLegalEntitiesModule}.
@@ -308,6 +410,11 @@ export interface AdminClient {
         reports: PlatformReportsModule;
         /** Basic health of the platform's own servers (CPU, memory, disk, network). */
         serverMetrics: PlatformServerMetricsModule;
+        /**
+         * The platform's tax categories and tax rates every store shares: create, change and delete
+         * them — see {@link PlatformTaxModule}. Reads are `tax.categories` / `tax.rates`.
+         */
+        tax: PlatformTaxModule;
     };
     /** A derived client on another tenant, sharing this one's principal. */
     withTenant(tenant: Partial<TenantContext> & {