@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/stock/by-location.js

@@ -0,0 +1,94 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+export const STOCK_LEVELS_AT_LOCATION_QUERY = /* GraphQL */ `
+  query StockLevelsAtLocation($locationId: ID!, $options: StockLevelListOptions) {
+    stockLevelsByLocation(locationId: $locationId, options: $options) {
+      items {
+        id
+        stockOnHand
+        stockAllocated
+        updatedAt
+        productVariant {
+          id
+          name
+          sku
+          product { id name featuredAsset { id preview } }
+        }
+      }
+      totalItems
+    }
+  }
+`;
+export const STOCK_MOVEMENTS_AT_LOCATION_QUERY = /* GraphQL */ `
+  query StockMovementsAtLocation($locationId: ID!, $options: StockMovementListOptions) {
+    stockMovementsByLocation(locationId: $locationId, options: $options) {
+      items {
+        id
+        createdAt
+        type
+        quantity
+        productVariant { id name sku }
+        orderLine { order { id code } }
+      }
+      totalItems
+    }
+  }
+`;
+const toLevel = ({ productVariant, ...level }) => ({
+    id: level.id,
+    variantId: productVariant.id,
+    sku: productVariant.sku,
+    variantName: productVariant.name,
+    product: {
+        id: productVariant.product.id,
+        name: productVariant.product.name,
+        featuredAsset: productVariant.product.featuredAsset ?? null,
+    },
+    onHand: level.stockOnHand,
+    allocated: level.stockAllocated,
+    updatedAt: level.updatedAt,
+});
+const toMovement = ({ productVariant, orderLine, ...movement }) => ({
+    ...movement,
+    variantId: productVariant.id,
+    sku: productVariant.sku,
+    variantName: productVariant.name,
+    order: orderLine?.order ?? null,
+});
+const DEFAULT_PAGE_SIZE = 25;
+const firstSkip = (filter) => filter?.after === undefined ? 0 : readOffsetCursor(filter.after);
+export function createStockByLocationReads(transport) {
+    const levelsPage = async (locationId, skip, take, filter) => {
+        const search = filter?.search?.trim();
+        const data = await transport.graphql({
+            api: 'admin',
+            query: STOCK_LEVELS_AT_LOCATION_QUERY,
+            variables: {
+                locationId,
+                options: { skip, take, sort: filter?.sort ?? 'DESC', ...(search ? { search } : {}) },
+            },
+        }, filter);
+        return pageFromVendureList({
+            items: data.stockLevelsByLocation.items.map(toLevel),
+            totalItems: data.stockLevelsByLocation.totalItems,
+        }, skip, take, (cursor) => levelsPage(locationId, readOffsetCursor(cursor), take, filter));
+    };
+    const movementsPage = async (locationId, skip, take, filter) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: STOCK_MOVEMENTS_AT_LOCATION_QUERY,
+            variables: { locationId, options: { skip, take } },
+        }, filter);
+        return pageFromVendureList({
+            items: data.stockMovementsByLocation.items.map(toMovement),
+            totalItems: data.stockMovementsByLocation.totalItems,
+        }, skip, take, (cursor) => movementsPage(locationId, readOffsetCursor(cursor), take, filter));
+    };
+    return {
+        levelsAt(locationId, filter) {
+            return levelsPage(locationId, firstSkip(filter), filter?.limit ?? DEFAULT_PAGE_SIZE, filter);
+        },
+        movementsAt(locationId, filter) {
+            return movementsPage(locationId, firstSkip(filter), filter?.limit ?? DEFAULT_PAGE_SIZE, filter);
+        },
+    };
+}

package/dist/stock/index.d.ts

@@ -1,5 +1,8 @@
 import { type Page, type Transport } from '@sixtyninecommerce/core';
 import type { Call, ListOptions } from '../types.js';
+import { type StockByLocationReads } from './by-location.js';
+import { type StockLocationsModule } from './locations.js';
+import { type StockSettingsModule } from './settings.js';
 import { type StockTransfersModule } from './transfers.js';
 /**
  * One variant's stock at one location, in integer units.
@@ -14,7 +17,10 @@ import { type StockTransfersModule } from './transfers.js';
  *   allocates past on-hand, and that shortfall shows as a negative figure. A
  *   negative threshold (an oversell allowance) raises it above
  *   `onHand − allocated`.
- * - `incoming` — open units expected at this location (purchase orders).
+ * - `incoming` — open units expected at this location (purchase orders), customer-facing: a
+ *   purchase order counts only what its supplier confirmed.
+ * - `onOrder` — units ordered from suppliers and still to come at this location, confirmed or
+ *   not: the remainders of sent purchase orders plus the open lines an ERP mirrors. Internal.
  * - `trackInventory: false` — the variant does not track stock, so none of
  *   these figures gates a sale.
  */
@@ -25,6 +31,7 @@ export interface StockPosition {
     allocated: number;
     available: number;
     incoming: number;
+    onOrder: number;
     reserved: number;
     trackInventory: boolean;
 }
@@ -128,7 +135,7 @@ export interface StockAllocationsModule {
  * narrowed to that list instead); `STOCK_LOCATION_REQUIRED` and
  * `STOCK_WOULD_GO_NEGATIVE` (→ `BusinessRuleError`).
  */
-export interface StockModule {
+export interface StockModule extends StockByLocationReads {
     /** The variant's stock at every location of this store (or one). A location that never held it has no entry. */
     position(variantId: string, options?: StockPositionOptions): Promise<StockPosition[]>;
     /** The variant's ledger at this store's locations, with each movement's reason. */
@@ -158,9 +165,16 @@ export interface StockModule {
     /** Stock transfers between this store's locations, and consumptions at one. */
     transfers: StockTransfersModule;
     allocations: StockAllocationsModule;
+    /** The store's stock locations themselves: list, read, create, change, delete. */
+    locations: StockLocationsModule;
+    /**
+     * The store's stock settings as the engine reads them, saved or previewed: tracking, the
+     * threshold, exposure to the storefront, the storefront warehouses and the backorder default.
+     */
+    settings: StockSettingsModule;
 }
-export declare const STOCK_POSITION_QUERY = "\n  query StockPosition($variantId: ID!, $locationId: ID) {\n    stockPosition(variantId: $variantId, locationId: $locationId) { \n  locationId\n  locationName\n  onHand\n  allocated\n  available\n  incoming\n  reserved\n  trackInventory\n }\n  }\n";
+export declare const STOCK_POSITION_QUERY = "\n  query StockPosition($variantId: ID!, $locationId: ID) {\n    stockPosition(variantId: $variantId, locationId: $locationId) { \n  locationId\n  locationName\n  onHand\n  allocated\n  available\n  incoming\n  onOrder\n  reserved\n  trackInventory\n }\n  }\n";
 export declare const STOCK_MOVEMENTS_QUERY: string;
-export declare const ADJUST_STOCK_MUTATION = "\n  mutation AdjustStock($input: AdjustStockInput!, $idempotencyKey: String) {\n    adjustStock(input: $input, idempotencyKey: $idempotencyKey) { \n  locationId\n  locationName\n  onHand\n  allocated\n  available\n  incoming\n  reserved\n  trackInventory\n }\n  }\n";
+export declare const ADJUST_STOCK_MUTATION = "\n  mutation AdjustStock($input: AdjustStockInput!, $idempotencyKey: String) {\n    adjustStock(input: $input, idempotencyKey: $idempotencyKey) { \n  locationId\n  locationName\n  onHand\n  allocated\n  available\n  incoming\n  onOrder\n  reserved\n  trackInventory\n }\n  }\n";
 export declare const RELEASE_ORDER_ALLOCATION_MUTATION = "\n  mutation ReleaseOrderAllocation($orderId: ID!) {\n    releaseOrderAllocation(orderId: $orderId) {\n      __typename\n      ... on ReleaseOrderAllocationSuccess { orderId releasedQuantity }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
 export declare function createStockModule(transport: Transport): StockModule;

package/dist/stock/index.js

@@ -1,4 +1,7 @@
 import { errorFromErrorResult, isErrorResult, pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { createStockByLocationReads } from './by-location.js';
+import { createStockLocationsModule } from './locations.js';
+import { createStockSettingsModule } from './settings.js';
 import { createStockTransfersModule } from './transfers.js';
 const POSITION_FIELDS = /* GraphQL */ `
   locationId
@@ -7,6 +10,7 @@ const POSITION_FIELDS = /* GraphQL */ `
   allocated
   available
   incoming
+  onOrder
   reserved
   trackInventory
 `;
@@ -101,6 +105,9 @@ export function createStockModule(transport) {
             return data.adjustStock;
         },
         transfers: createStockTransfersModule(transport),
+        locations: createStockLocationsModule(transport),
+        settings: createStockSettingsModule(transport),
+        ...createStockByLocationReads(transport),
         allocations: {
             async release(orderId, options) {
                 const data = await transport.graphql({ api: 'admin', query: RELEASE_ORDER_ALLOCATION_MUTATION, variables: { orderId } }, options);

package/dist/stock/locations.d.ts

@@ -0,0 +1,144 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * One stock location (warehouse, shop, back room) of the store the client is on.
+ *
+ * The parcel sender (`address`, the default sender) is not here: it has its own door
+ * (`locations.upsert` for the address, MyParcel's sender card for the default), with rules
+ * these methods cannot apply.
+ */
+export interface StockLocation {
+    id: string;
+    name: string;
+    /** Empty when none was given. */
+    description: string;
+    /** ISO 8601, UTC. */
+    createdAt: string;
+    /** ISO 8601, UTC. */
+    updatedAt: string;
+    /**
+     * Whether shoppers see this location's stock (the Shop API's per-variant availability). True
+     * unless set off, for a back room or a staging area.
+     */
+    isPublic: boolean;
+    /**
+     * This location's own out-of-stock threshold, in units: non-zero replaces the variant's (or the
+     * store's) threshold for stock held here. Negative lets it sell that many below zero, positive
+     * holds a buffer back from sale; 0 uses the variant's or the store's.
+     */
+    outOfStockThreshold: number;
+}
+/** The fields a list can be sorted by. */
+export declare const STOCK_LOCATION_SORT_FIELDS: readonly ["name", "createdAt", "updatedAt"];
+export type StockLocationSortField = (typeof STOCK_LOCATION_SORT_FIELDS)[number];
+export interface StockLocationListOptions extends ListOptions {
+    /**
+     * Locations whose name OR description contains this, ignoring case (the engine's list filter;
+     * the search index is not used). Blank or omitted: every location.
+     */
+    term?: string;
+    /** One key. Omitted: the engine's own order. */
+    sort?: {
+        field: StockLocationSortField;
+        direction: 'ASC' | 'DESC';
+    };
+}
+export interface CreateStockLocationInput {
+    name: string;
+    description?: string;
+    /** On (shoppers see its stock) when omitted. */
+    isPublic?: boolean;
+    /** 0 (use the variant's or the store's threshold) when omitted. */
+    outOfStockThreshold?: number;
+}
+/** A PATCH: an absent field keeps what the location has. */
+export interface UpdateStockLocationInput {
+    name?: string;
+    description?: string;
+    isPublic?: boolean;
+    outOfStockThreshold?: number;
+}
+export interface DeleteStockLocationOptions extends Call {
+    /**
+     * Another location of this store that takes over the deleted location's stock levels. Omitted:
+     * the levels go with the location.
+     */
+    transferToLocationId?: string;
+}
+/**
+ * `admin.stock.locations`: the store's stock locations themselves (spec §9.2 `stock`, §8.7). A
+ * location's profile (code, time zone, opening hours, address) is `admin.locations`; its pickup
+ * settings are `admin.locations.pickup`.
+ *
+ * Scoped to the store the client is on: another store's location is not listed, `get` answers
+ * `null` for it, and `update`/`delete` refuse it `ENTITY_NOT_FOUND` (`NotFoundError`), the same
+ * answer as for an id that does not exist. A location SHARED with another store is changed or
+ * deleted only by a caller who may do so in every store holding it (`ENTITY_NOT_FOUND` too
+ * otherwise).
+ *
+ * A hub-owned location (multi-region phase 5) will be refused `MANAGED_BY_ORGANIZATION`
+ * (`BusinessRuleError`) by `update` and `delete` from a member store; no location is hub-owned
+ * yet. A member store's Stock owner (an app or API token owning the Stock field group) never
+ * locks the hub's warehouse (ruling U8).
+ */
+export interface StockLocationsModule {
+    /**
+     * The store's locations, a page at a time (`options.limit`, default 100, at most 1,000; and
+     * `options.after` from a previous page); `for await (const location of page)` walks them all.
+     * An API token or app restricted with `locationIds` still lists every location of the store.
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    list(options?: StockLocationListOptions): Promise<Page<StockLocation>>;
+    /**
+     * One location by id, or `null` when the store has no such location (one only another store
+     * holds reads the same).
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    get(id: string, options?: Call): Promise<StockLocation | null>;
+    /**
+     * Create a location in this store. `name` must not be blank (`STOCK_LOCATION_INPUT_INVALID`,
+     * `ValidationError`, before anything is sent).
+     *
+     * @effect write
+     * @permission CreateStockLocation
+     */
+    create(input: CreateStockLocationInput, options?: Call): Promise<StockLocation>;
+    /**
+     * Change a location's name, description, `isPublic` or threshold. Moves no stock, so a
+     * credential restricted with `locationIds` may change any location of the store. A blank
+     * `name` is `STOCK_LOCATION_INPUT_INVALID` (`ValidationError`, nothing sent). The engine also
+     * refuses `STOCK_LOCATION_SENDER_READ_ONLY` (`BusinessRuleError`) a change to the parcel sender,
+     * which this method never sends.
+     *
+     * @effect write
+     * @permission UpdateStockLocation
+     */
+    update(id: string, input: UpdateStockLocationInput, options?: Call): Promise<StockLocation>;
+    /**
+     * Delete a location. Its stock levels move to `options.transferToLocationId`, or are deleted
+     * with it: there is no undo.
+     *
+     * Refused:
+     * - `STOCK_LOCATION_NOT_DELETED` (`BusinessRuleError`), in the engine's words, when the engine
+     *   keeps it (the store's last location, for one);
+     * - `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`) to a credential restricted with
+     *   `locationIds` that does not hold the location and the transfer target;
+     * - `FIELD_GROUP_LOCKED` (`BusinessRuleError`) while an app or API token owns the store's Stock
+     *   and the location holds stock;
+     * - `ENTITY_NOT_FOUND` (`NotFoundError`) for another store's location or the transfer target.
+     *
+     * @effect destructive
+     * @permission DeleteStockLocation
+     */
+    delete(id: string, options?: DeleteStockLocationOptions): Promise<void>;
+}
+export declare const STOCK_LOCATIONS_QUERY = "\n  query StockLocations($options: StockLocationListOptions) {\n    stockLocations(options: $options) {\n      items { \n  id\n  name\n  description\n  createdAt\n  updatedAt\n  customFields {\n    isPublic\n    outOfStockThreshold\n  }\n }\n      totalItems\n    }\n  }\n";
+export declare const STOCK_LOCATION_QUERY = "\n  query StockLocation($id: ID!) {\n    stockLocation(id: $id) { \n  id\n  name\n  description\n  createdAt\n  updatedAt\n  customFields {\n    isPublic\n    outOfStockThreshold\n  }\n }\n  }\n";
+export declare const CREATE_STOCK_LOCATION_MUTATION = "\n  mutation CreateStockLocation($input: CreateStockLocationInput!) {\n    createStockLocation(input: $input) { \n  id\n  name\n  description\n  createdAt\n  updatedAt\n  customFields {\n    isPublic\n    outOfStockThreshold\n  }\n }\n  }\n";
+export declare const UPDATE_STOCK_LOCATION_MUTATION = "\n  mutation UpdateStockLocation($input: UpdateStockLocationInput!) {\n    updateStockLocation(input: $input) { \n  id\n  name\n  description\n  createdAt\n  updatedAt\n  customFields {\n    isPublic\n    outOfStockThreshold\n  }\n }\n  }\n";
+export declare const DELETE_STOCK_LOCATION_MUTATION = "\n  mutation DeleteStockLocation($input: DeleteStockLocationInput!) {\n    deleteStockLocation(input: $input) {\n      result\n      message\n    }\n  }\n";
+export declare function createStockLocationsModule(transport: Transport): StockLocationsModule;

package/dist/stock/locations.js

@@ -0,0 +1,168 @@
+import { BusinessRuleError, pageFromVendureList, readOffsetCursor, ValidationError, } from '@sixtyninecommerce/core';
+import { fieldOf } from '../catalog/types.js';
+/** The fields a list can be sorted by. */
+export const STOCK_LOCATION_SORT_FIELDS = ['name', 'createdAt', 'updatedAt'];
+const LOCATION_FIELDS = /* GraphQL */ `
+  id
+  name
+  description
+  createdAt
+  updatedAt
+  customFields {
+    isPublic
+    outOfStockThreshold
+  }
+`;
+export const STOCK_LOCATIONS_QUERY = /* GraphQL */ `
+  query StockLocations($options: StockLocationListOptions) {
+    stockLocations(options: $options) {
+      items { ${LOCATION_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const STOCK_LOCATION_QUERY = /* GraphQL */ `
+  query StockLocation($id: ID!) {
+    stockLocation(id: $id) { ${LOCATION_FIELDS} }
+  }
+`;
+export const CREATE_STOCK_LOCATION_MUTATION = /* GraphQL */ `
+  mutation CreateStockLocation($input: CreateStockLocationInput!) {
+    createStockLocation(input: $input) { ${LOCATION_FIELDS} }
+  }
+`;
+export const UPDATE_STOCK_LOCATION_MUTATION = /* GraphQL */ `
+  mutation UpdateStockLocation($input: UpdateStockLocationInput!) {
+    updateStockLocation(input: $input) { ${LOCATION_FIELDS} }
+  }
+`;
+export const DELETE_STOCK_LOCATION_MUTATION = /* GraphQL */ `
+  mutation DeleteStockLocation($input: DeleteStockLocationInput!) {
+    deleteStockLocation(input: $input) {
+      result
+      message
+    }
+  }
+`;
+const DEFAULT_PAGE_SIZE = 100;
+function toLocation(wire) {
+    return {
+        id: wire.id,
+        name: wire.name,
+        description: wire.description ?? '',
+        createdAt: wire.createdAt,
+        updatedAt: wire.updatedAt,
+        // The column defaults: a row written before the field existed reads null.
+        isPublic: wire.customFields?.isPublic ?? true,
+        outOfStockThreshold: wire.customFields?.outOfStockThreshold ?? 0,
+    };
+}
+const invalidInput = (message) => new ValidationError({
+    code: 'STOCK_LOCATION_INPUT_INVALID',
+    message,
+    status: 400,
+    service: 'vendure',
+});
+function assertId(id, what = 'id') {
+    if (typeof id !== 'string' || id.trim() === '') {
+        throw invalidInput(`${what} must be a stock location id.`);
+    }
+}
+function assertName(name) {
+    if (typeof name !== 'string' || name.trim() === '') {
+        throw invalidInput('A stock location needs a name.');
+    }
+}
+/** The location's own custom fields, only the keys the caller set: never the sender fields. */
+function customFieldsOf(input) {
+    const fields = {};
+    if (input.isPublic !== undefined)
+        fields.isPublic = input.isPublic;
+    if (input.outOfStockThreshold !== undefined)
+        fields.outOfStockThreshold = input.outOfStockThreshold;
+    return Object.keys(fields).length > 0 ? fields : undefined;
+}
+function listOptionsOf(skip, take, options) {
+    const term = options?.term?.trim() ?? '';
+    return {
+        skip,
+        take,
+        ...(term === ''
+            ? {}
+            : {
+                filter: { name: { contains: term }, description: { contains: term } },
+                filterOperator: 'OR',
+            }),
+        ...(options?.sort ? { sort: { [options.sort.field]: options.sort.direction } } : {}),
+    };
+}
+export function createStockLocationsModule(transport) {
+    const listPage = async (skip, take, options) => {
+        const list = await fieldOf(transport, STOCK_LOCATIONS_QUERY, 'stockLocations', { options: listOptionsOf(skip, take, options) }, options);
+        return pageFromVendureList({ items: list.items.map(toLocation), totalItems: list.totalItems }, skip, take, (cursor) => listPage(readOffsetCursor(cursor), take, options));
+    };
+    return {
+        list(options) {
+            if (options?.sort && !STOCK_LOCATION_SORT_FIELDS.includes(options.sort.field)) {
+                return Promise.reject(invalidInput(`sort.field must be one of ${STOCK_LOCATION_SORT_FIELDS.join(', ')}.`));
+            }
+            const take = options?.limit ?? DEFAULT_PAGE_SIZE;
+            const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return listPage(skip, take, options);
+        },
+        async get(id, options) {
+            assertId(id);
+            const wire = await fieldOf(transport, STOCK_LOCATION_QUERY, 'stockLocation', { id }, options);
+            return wire === null ? null : toLocation(wire);
+        },
+        async create(input, options) {
+            assertName(input?.name);
+            const customFields = customFieldsOf(input);
+            return toLocation(await fieldOf(transport, CREATE_STOCK_LOCATION_MUTATION, 'createStockLocation', {
+                input: {
+                    name: input.name,
+                    description: input.description ?? '',
+                    ...(customFields ? { customFields } : {}),
+                },
+            }, options));
+        },
+        async update(id, input, options) {
+            assertId(id);
+            if (input?.name !== undefined)
+                assertName(input.name);
+            const customFields = customFieldsOf(input ?? {});
+            return toLocation(await fieldOf(transport, UPDATE_STOCK_LOCATION_MUTATION, 'updateStockLocation', {
+                input: {
+                    id,
+                    ...(input?.name !== undefined ? { name: input.name } : {}),
+                    ...(input?.description !== undefined ? { description: input.description } : {}),
+                    // Core applies customFields key by key: the sender fields are never named here.
+                    ...(customFields ? { customFields } : {}),
+                },
+            }, options));
+        },
+        async delete(id, options) {
+            assertId(id);
+            if (options?.transferToLocationId !== undefined) {
+                assertId(options.transferToLocationId, 'transferToLocationId');
+            }
+            const response = await fieldOf(transport, DELETE_STOCK_LOCATION_MUTATION, 'deleteStockLocation', {
+                input: {
+                    id,
+                    ...(options?.transferToLocationId
+                        ? { transferToLocationId: options.transferToLocationId }
+                        : {}),
+                },
+            }, options);
+            if (response?.result === 'DELETED')
+                return;
+            // Answered at HTTP 200, so the transport never throws for it.
+            throw new BusinessRuleError({
+                code: 'STOCK_LOCATION_NOT_DELETED',
+                message: response?.message?.trim() || 'The stock location was not deleted.',
+                status: 422,
+                service: 'vendure',
+            });
+        },
+    };
+}

package/dist/stock/settings.d.ts

@@ -0,0 +1,106 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** The store's default for ordering beyond saleable stock: never, up to stock on order, any quantity. */
+export type StockBackorderPolicy = 'deny' | 'incoming' | 'unlimited';
+/**
+ * How the storefront warehouse selection reads: `ALL` (no selection, every warehouse), `SUBSET`
+ * (only the listed ones), or `MALFORMED` (the stored value cannot be read; the engine sells from
+ * every warehouse and logs it, and saving a selection replaces it).
+ */
+export type StorefrontStockLocationSelectionMode = 'ALL' | 'SUBSET' | 'MALFORMED';
+export interface StorefrontStockLocations {
+    mode: StorefrontStockLocationSelectionMode;
+    /** The selected stock location ids, trimmed and de-duplicated (`SUBSET` only); else empty. */
+    locationIds: string[];
+    /** Why the stored value cannot be read (`MALFORMED` only); else null. */
+    reason: string | null;
+}
+/** A store's stock settings as the engine reads them. */
+export interface StockSettings {
+    /** The channel the settings are stored on. */
+    channelId: string;
+    /**
+     * The store's own "track inventory" value; `null` = the store inherits
+     * {@link defaultTrackInventory}. It decides availability for this store's customers: a variant
+     * set to inherit tracks by it (a variant's own `TRUE`/`FALSE` wins), and an untracked variant
+     * is always available (saleable stock, add to cart, checkout, the storefront `stockLevel`,
+     * search, the till, feeds).
+     */
+    trackInventory: boolean | null;
+    /**
+     * The store's own out-of-stock threshold; `null` = the store inherits
+     * {@link defaultOutOfStockThreshold}. A variant on the global threshold (its own threshold
+     * wins otherwise, and a warehouse's own threshold wins at that warehouse) is unavailable once
+     * its stock on hand less allocations falls to it.
+     */
+    outOfStockThreshold: number | null;
+    /** The platform default a store that inherits tracks by. */
+    defaultTrackInventory: boolean;
+    /** The platform default threshold a store that inherits uses. */
+    defaultOutOfStockThreshold: number;
+    /** Whether the Shop API exposes operational stock numbers (on hand, allocated, saleable). */
+    exposeStockToStorefront: boolean;
+    /** Which warehouses back the storefront's saleable stock and its orders' reservations. */
+    storefrontStockLocations: StorefrontStockLocations;
+    /** The store's backorder default; a variant may override it. Unreadable reads `deny`. */
+    backorderPolicy: StockBackorderPolicy;
+}
+/** A change to the stock settings. An omitted field keeps the stored value. */
+export interface StockSettingsPatch {
+    /**
+     * `null` = inherit the platform default. Changes which of this store's variants are available
+     * (see {@link StockSettings.trackInventory}).
+     */
+    trackInventory?: boolean | null;
+    /** `null` = inherit the platform default (see {@link StockSettings.outOfStockThreshold}). */
+    outOfStockThreshold?: number | null;
+    exposeStockToStorefront?: boolean;
+    /** Stock location ids of the store; `[]` clears the selection (every warehouse). */
+    storefrontStockLocationIds?: string[];
+    backorderPolicy?: StockBackorderPolicy;
+}
+/**
+ * The ACTIVE store's stock settings (`admin.stock.settings`). Reading needs any administrator
+ * permission on the store; writing needs `UpdateChannel` (the settings are stored on the channel
+ * and written through core `updateChannel`).
+ *
+ * The engine owns every rule: how a stored value reads is never worked out in the client. Ask
+ * {@link preview} for a change that is not saved.
+ */
+export interface StockSettingsModule {
+    /**
+     * The settings as the engine reads them. An unreadable warehouse selection is `MALFORMED`, an
+     * unreadable backorder policy is `deny`, an unreadable exposure flag is off.
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<StockSettings>;
+    /**
+     * How the settings WOULD read with `patch` applied, without saving anything.
+     *
+     * Refused `CHANNEL_SETTINGS_INVALID` (`ValidationError`, one `details[]` entry per field, named
+     * like `customFields.backorderPolicy`) for a change the save would refuse: a `null` track
+     * inventory, threshold, exposure flag or policy, a policy that is not exactly one of the values,
+     * a blank warehouse id, or more than 500 warehouses. A malformed warehouse id is refused
+     * `ENTITY_NOT_FOUND` (`NotFoundError`).
+     *
+     * @effect read
+     */
+    preview(patch: StockSettingsPatch, options?: Call): Promise<StockSettings>;
+    /**
+     * Save `patch`, and answer the settings as the engine now reads them. Only the fields named are
+     * written; the warehouse list is stored as the engine reads it (trimmed, de-duplicated, `[]` as
+     * no selection).
+     *
+     * Refused, before anything is written, as {@link preview} refuses. Refused by the save itself:
+     * `FORBIDDEN` without `UpdateChannel`. A warehouse id that is not a stock location of the store
+     * is stored and ignored by the engine (it never widens the store's warehouses).
+     *
+     * @effect write
+     */
+    set(patch: StockSettingsPatch, options?: Call): Promise<StockSettings>;
+}
+export declare const STOCK_SETTINGS_QUERY = "\n  query StockSettings {\n    stockSettings { \n  channelId\n  trackInventory\n  outOfStockThreshold\n  defaultTrackInventory\n  defaultOutOfStockThreshold\n  exposeStockToStorefront\n  storefrontStockLocations {\n    mode\n    locationIds\n    reason\n  }\n  backorderPolicy\n }\n  }\n";
+export declare const PREVIEW_STOCK_SETTINGS_QUERY = "\n  query PreviewStockSettings($input: StockSettingsInput!) {\n    previewStockSettings(input: $input) { \n  channelId\n  trackInventory\n  outOfStockThreshold\n  defaultTrackInventory\n  defaultOutOfStockThreshold\n  exposeStockToStorefront\n  storefrontStockLocations {\n    mode\n    locationIds\n    reason\n  }\n  backorderPolicy\n }\n  }\n";
+export declare const SET_STOCK_SETTINGS_MUTATION = "\n  mutation SetStockSettings($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { id }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+export declare function createStockSettingsModule(transport: Transport): StockSettingsModule;