@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/shipping/rate-tables.js

@@ -0,0 +1,390 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { assertDeleted, fieldOf } from '../catalog/types.js';
+const SUMMARY_FIELDS = /* GraphQL */ `
+  id
+  name
+  volumetricDivisor
+  defaultWeightGrams
+  enabled
+  createdAt
+  updatedAt
+`;
+const MEMBER_FIELDS = /* GraphQL */ `
+  id
+  countryCode
+  postalCodeFrom
+  postalCodeTo
+`;
+const RATE_FIELDS = /* GraphQL */ `
+  id
+  minWeightGrams
+  maxWeightGrams
+  price
+  currencyCode
+`;
+/** One selection for a zone wherever it is read or answered, so every door answers the same zone. */
+const ZONE_FIELDS = /* GraphQL */ `
+  id
+  name
+  type
+  position
+  members { ${MEMBER_FIELDS} }
+  rates { ${RATE_FIELDS} }
+  createdAt
+  updatedAt
+`;
+/** One selection for the single read and both writes, so all three answer the same table. */
+const TABLE_FIELDS = /* GraphQL */ `
+  ${SUMMARY_FIELDS}
+  zones { ${ZONE_FIELDS} }
+`;
+export const RATE_TABLES_QUERY = /* GraphQL */ `
+  query StoreRateTables {
+    shippingZoneConfigs { ${SUMMARY_FIELDS} }
+  }
+`;
+export const RATE_TABLE_QUERY = /* GraphQL */ `
+  query StoreRateTable($id: ID!) {
+    shippingZoneConfig(id: $id) { ${TABLE_FIELDS} }
+  }
+`;
+export const CREATE_RATE_TABLE_MUTATION = /* GraphQL */ `
+  mutation CreateStoreRateTable($input: CreateShippingZoneConfigInput!) {
+    createShippingZoneConfig(input: $input) { ${TABLE_FIELDS} }
+  }
+`;
+export const UPDATE_RATE_TABLE_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreRateTable($id: ID!, $input: UpdateShippingZoneConfigInput!) {
+    updateShippingZoneConfig(id: $id, input: $input) { ${TABLE_FIELDS} }
+  }
+`;
+export const DELETE_RATE_TABLE_MUTATION = /* GraphQL */ `
+  mutation DeleteStoreRateTable($id: ID!) {
+    deleteShippingZoneConfig(id: $id) {
+      result
+      message
+    }
+  }
+`;
+export const CREATE_RATE_TABLE_ZONE_MUTATION = /* GraphQL */ `
+  mutation CreateStoreRateTableZone($configId: ID!, $input: CreateShippingZoneInput!) {
+    createShippingZone(configId: $configId, input: $input) { ${ZONE_FIELDS} }
+  }
+`;
+export const UPDATE_RATE_TABLE_ZONE_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreRateTableZone($id: ID!, $input: UpdateShippingZoneInput!) {
+    updateShippingZone(id: $id, input: $input) { ${ZONE_FIELDS} }
+  }
+`;
+export const DELETE_RATE_TABLE_ZONE_MUTATION = /* GraphQL */ `
+  mutation DeleteStoreRateTableZone($id: ID!) {
+    deleteShippingZone(id: $id) {
+      result
+      message
+    }
+  }
+`;
+export const REORDER_RATE_TABLE_ZONES_MUTATION = /* GraphQL */ `
+  mutation ReorderStoreRateTableZones($configId: ID!, $zoneIds: [ID!]!) {
+    reorderShippingZones(configId: $configId, zoneIds: $zoneIds) { ${ZONE_FIELDS} }
+  }
+`;
+export const SET_RATE_TABLE_ZONE_MEMBERS_MUTATION = /* GraphQL */ `
+  mutation SetStoreRateTableZoneMembers($zoneId: ID!, $members: [ShippingZoneMemberInput!]!) {
+    setShippingZoneMembers(zoneId: $zoneId, members: $members) { ${MEMBER_FIELDS} }
+  }
+`;
+export const SET_RATE_TABLE_ZONE_RATES_MUTATION = /* GraphQL */ `
+  mutation SetStoreRateTableZoneRates($zoneId: ID!, $rates: [ShippingRateInput!]!) {
+    setShippingRates(zoneId: $zoneId, rates: $rates) { ${RATE_FIELDS} }
+  }
+`;
+/** GraphQL's `Int`: a 32-bit signed integer. A wider number cannot be sent at all. */
+const INT_MIN = -2_147_483_648;
+const INT_MAX = 2_147_483_647;
+/**
+ * Collects every problem of one call, and refuses them in ONE error with the engine's code and
+ * JSON Pointers, so a caller marks each field the same way whichever side refused.
+ */
+class Problems {
+    details = [];
+    add(field, code, message) {
+        this.details.push({ field, code, message });
+    }
+    throwIfAny() {
+        const [first, ...rest] = this.details;
+        if (!first)
+            return;
+        const more = rest.length;
+        throw new ValidationError({
+            code: 'SHIPPING_ZONE_INPUT_INVALID',
+            message: more === 0
+                ? first.message
+                : `${first.message} ${String(more)} more ${more === 1 ? 'problem' : 'problems'} with this save.`,
+            status: 400,
+            service: 'vendure',
+            details: this.details,
+        });
+    }
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * A whole number GraphQL's `Int` carries. Whether it is a sensible value (not negative) is the
+ * engine's to judge, so this refuses only what could not be sent.
+ */
+function intInput(problems, field, label, value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value)) {
+        problems.add(field, 'type', `${label} must be a whole number.`);
+    }
+    else if (value > INT_MAX) {
+        problems.add(field, 'maximum', `${label} must be at most ${String(INT_MAX)}.`);
+    }
+    else if (value < INT_MIN) {
+        problems.add(field, 'minimum', `${label} cannot be negative.`);
+    }
+}
+/**
+ * The input as the engine takes it, with only the fields the caller named. An explicit `null`
+ * goes through as sent: the engine says which field cannot be cleared.
+ */
+function tableInput(input, mode) {
+    const problems = new Problems();
+    if (!isObject(input)) {
+        problems.add('/input', 'type', mode === 'create'
+            ? 'A new rate table must be an object.'
+            : 'The change to a rate table must be an object.');
+        problems.throwIfAny();
+    }
+    const fields = input;
+    const out = {};
+    // A create's name is `String!`: null cannot be sent at all (only an update may send null, which
+    // the engine refuses as "cannot be cleared").
+    if (fields.name == null && mode === 'create') {
+        problems.add('/input/name', 'required', 'Give the rate table a name.');
+    }
+    else if (fields.name !== undefined) {
+        if (fields.name !== null && typeof fields.name !== 'string') {
+            problems.add('/input/name', 'type', 'The rate table name must be text.');
+        }
+        out.name = fields.name;
+    }
+    const numbers = [
+        ['volumetricDivisor', 'The volumetric divisor'],
+        ['defaultWeightGrams', 'The default weight'],
+    ];
+    for (const [key, label] of numbers) {
+        const value = fields[key];
+        if (value === undefined)
+            continue;
+        if (value !== null)
+            intInput(problems, `/input/${key}`, label, value);
+        out[key] = value;
+    }
+    if (mode === 'update' && fields.enabled !== undefined) {
+        if (fields.enabled !== null && typeof fields.enabled !== 'boolean') {
+            problems.add('/input/enabled', 'type', 'Enabled must be true or false.');
+        }
+        out.enabled = fields.enabled;
+    }
+    problems.throwIfAny();
+    return out;
+}
+/** `field` is the operation's own argument (`/id`, `/configId`, `/zoneId`). */
+const requireId = (id, field = '/id', what = 'a rate table id') => {
+    if (typeof id !== 'string' || id === '') {
+        const problems = new Problems();
+        problems.add(field, 'type', `${field.slice(1)} must be ${what}.`);
+        problems.throwIfAny();
+    }
+    return id;
+};
+/**
+ * A zone's input as the engine takes it, with only the fields the caller named. A create's name
+ * and type are `String!`, so a missing one cannot be sent; every other `null` goes through as
+ * sent (a create reads a null position as "after the last zone", an update refuses it).
+ */
+function zoneInput(input, mode) {
+    const problems = new Problems();
+    if (!isObject(input)) {
+        problems.add('/input', 'type', mode === 'create'
+            ? 'A new zone must be an object.'
+            : 'The change to a zone must be an object.');
+        problems.throwIfAny();
+    }
+    const fields = input;
+    const out = {};
+    const texts = [
+        ['name', 'Give the zone a name.', 'The zone name must be text.'],
+        [
+            'type',
+            'Give the zone a type: "domestic" (it matches postal-code ranges) or "international" (it matches countries).',
+            'The zone type must be text.',
+        ],
+    ];
+    for (const [key, missing, notText] of texts) {
+        const value = fields[key];
+        if (value == null && mode === 'create') {
+            problems.add(`/input/${key}`, 'required', missing);
+        }
+        else if (value !== undefined) {
+            if (value !== null && typeof value !== 'string') {
+                problems.add(`/input/${key}`, 'type', notText);
+            }
+            out[key] = value;
+        }
+    }
+    if (fields.position !== undefined) {
+        if (fields.position !== null) {
+            intInput(problems, '/input/position', 'The position', fields.position);
+        }
+        out.position = fields.position;
+    }
+    problems.throwIfAny();
+    return out;
+}
+const MEMBER_TEXTS = [
+    ['countryCode', 'country'],
+    ['postalCodeFrom', 'postal-code start'],
+    ['postalCodeTo', 'postal-code end'],
+];
+/** Only the three member fields, each text or null; whether the zone matches it is the engine's. */
+function membersInput(members) {
+    const problems = new Problems();
+    if (!Array.isArray(members)) {
+        problems.add('/members', 'type', 'The members must be a list.');
+        problems.throwIfAny();
+    }
+    const out = members.map((member, index) => {
+        const at = `/members/${String(index)}`;
+        const row = {};
+        if (!isObject(member)) {
+            problems.add(at, 'type', `Member ${String(index + 1)} must be an object.`);
+            return row;
+        }
+        for (const [key, label] of MEMBER_TEXTS) {
+            const value = member[key];
+            if (value === undefined)
+                continue;
+            if (value !== null && typeof value !== 'string') {
+                problems.add(`${at}/${key}`, 'type', `Member ${String(index + 1)}'s ${label} must be text.`);
+            }
+            row[key] = value;
+        }
+        return row;
+    });
+    problems.throwIfAny();
+    return out;
+}
+const RATE_NUMBERS = [
+    ['minWeightGrams', 'a start weight'],
+    ['maxWeightGrams', 'an end weight'],
+    ['price', 'a price'],
+];
+/**
+ * Only the four tier fields. Each is non-null on the wire (`Int!`, `String!`), so a missing one
+ * cannot be sent; the tier's values (negative, ending before it starts, overlapping another, an
+ * unknown currency) are the engine's to judge.
+ */
+function ratesInput(rates) {
+    const problems = new Problems();
+    if (!Array.isArray(rates)) {
+        problems.add('/rates', 'type', 'The rates must be a list of weight tiers.');
+        problems.throwIfAny();
+    }
+    const out = rates.map((rate, index) => {
+        const at = `/rates/${String(index)}`;
+        const tier = `Tier ${String(index + 1)}`;
+        if (!isObject(rate)) {
+            problems.add(at, 'type', `${tier} must be an object.`);
+            return {};
+        }
+        for (const [key, label] of RATE_NUMBERS) {
+            const value = rate[key];
+            if (value == null)
+                problems.add(`${at}/${key}`, 'required', `${tier} needs ${label}.`);
+            else
+                intInput(problems, `${at}/${key}`, `${tier}'s ${label.replace(/^an? /, '')}`, value);
+        }
+        if (rate.currencyCode == null) {
+            problems.add(`${at}/currencyCode`, 'required', `${tier} needs a currency.`);
+        }
+        else if (typeof rate.currencyCode !== 'string') {
+            problems.add(`${at}/currencyCode`, 'type', `${tier}'s currency must be text (ISO 4217, e.g. EUR).`);
+        }
+        return {
+            minWeightGrams: rate.minWeightGrams,
+            maxWeightGrams: rate.maxWeightGrams,
+            price: rate.price,
+            currencyCode: rate.currencyCode,
+        };
+    });
+    problems.throwIfAny();
+    return out;
+}
+/** A list of zone ids; whether it names every zone of the table once is the engine's. */
+function zoneIdsInput(zoneIds) {
+    const problems = new Problems();
+    if (!Array.isArray(zoneIds)) {
+        problems.add('/zoneIds', 'type', 'The zone order must be a list of zone ids.');
+        problems.throwIfAny();
+    }
+    zoneIds.forEach((id, index) => {
+        if (typeof id !== 'string' || id === '') {
+            problems.add(`/zoneIds/${String(index)}`, 'type', `Place ${String(index + 1)} must be a zone id.`);
+        }
+    });
+    problems.throwIfAny();
+    return zoneIds;
+}
+function createZonesModule(transport) {
+    return {
+        async create(tableId, input, options) {
+            const configId = requireId(tableId, '/configId');
+            return fieldOf(transport, CREATE_RATE_TABLE_ZONE_MUTATION, 'createShippingZone', { configId, input: zoneInput(input, 'create') }, options);
+        },
+        async update(zoneId, patch, options) {
+            const id = requireId(zoneId, '/id', 'a zone id');
+            return fieldOf(transport, UPDATE_RATE_TABLE_ZONE_MUTATION, 'updateShippingZone', { id, input: zoneInput(patch, 'update') }, options);
+        },
+        async delete(zoneId, options) {
+            assertDeleted('SHIPPING_ZONE_NOT_DELETED', [
+                await fieldOf(transport, DELETE_RATE_TABLE_ZONE_MUTATION, 'deleteShippingZone', { id: requireId(zoneId, '/id', 'a zone id') }, options),
+            ]);
+        },
+        async reorder(tableId, zoneIds, options) {
+            const configId = requireId(tableId, '/configId');
+            return fieldOf(transport, REORDER_RATE_TABLE_ZONES_MUTATION, 'reorderShippingZones', { configId, zoneIds: zoneIdsInput(zoneIds) }, options);
+        },
+        async setMembers(zoneId, members, options) {
+            const id = requireId(zoneId, '/zoneId', 'a zone id');
+            return fieldOf(transport, SET_RATE_TABLE_ZONE_MEMBERS_MUTATION, 'setShippingZoneMembers', { zoneId: id, members: membersInput(members) }, options);
+        },
+        async setRates(zoneId, rates, options) {
+            const id = requireId(zoneId, '/zoneId', 'a zone id');
+            return fieldOf(transport, SET_RATE_TABLE_ZONE_RATES_MUTATION, 'setShippingRates', { zoneId: id, rates: ratesInput(rates) }, options);
+        },
+    };
+}
+export function createRateTablesModule(transport) {
+    return {
+        async list(options) {
+            return fieldOf(transport, RATE_TABLES_QUERY, 'shippingZoneConfigs', {}, options);
+        },
+        async get(id, options) {
+            return fieldOf(transport, RATE_TABLE_QUERY, 'shippingZoneConfig', { id: requireId(id) }, options);
+        },
+        async create(input, options) {
+            return fieldOf(transport, CREATE_RATE_TABLE_MUTATION, 'createShippingZoneConfig', { input: tableInput(input, 'create') }, options);
+        },
+        async update(id, patch, options) {
+            const tableId = requireId(id);
+            return fieldOf(transport, UPDATE_RATE_TABLE_MUTATION, 'updateShippingZoneConfig', { id: tableId, input: tableInput(patch, 'update') }, options);
+        },
+        async delete(id, options) {
+            assertDeleted('SHIPPING_ZONE_CONFIG_NOT_DELETED', [
+                await fieldOf(transport, DELETE_RATE_TABLE_MUTATION, 'deleteShippingZoneConfig', { id: requireId(id) }, options),
+            ]);
+        },
+        zones: createZonesModule(transport),
+    };
+}

package/dist/shipping/ship-to-countries.d.ts

@@ -0,0 +1,75 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * How a store's ship-to list reads: `ALL` (no list: every enabled country is offered), `SUBSET`
+ * (only the listed countries are offered, and an order to any other cannot be placed), or
+ * `MALFORMED` (the stored value cannot be read; checkout offers every enabled country and logs
+ * it, and saving a list replaces it).
+ */
+export type ShipToCountriesGate = 'ALL' | 'SUBSET' | 'MALFORMED';
+/** One row of a ship-to picker. */
+export interface ShipToCountryOption {
+    /** ISO-3166 alpha-2 code, upper-case. */
+    code: string;
+    /** The country's name; a selected code that is not an enabled country shows as its code. */
+    name: string;
+    /** False for a selected code that is not an enabled country: no shopper can choose it. */
+    enabled: boolean;
+}
+/** The countries a store ships to, as checkout applies them. */
+export interface ShipToCountries {
+    gate: ShipToCountriesGate;
+    /** Why the stored value cannot be read (`MALFORMED` only); else null. */
+    reason: string | null;
+    /** The selected codes, trimmed, upper-cased and de-duplicated (`SUBSET` only); else empty. */
+    selected: string[];
+    /** The codes the storefront offers at checkout (Shop `availableCountries`), in its order. */
+    served: string[];
+    /**
+     * Selected codes that are not enabled countries: selected, but no shopper can choose them.
+     * Only a platform administrator enables a country (`platform.countries`).
+     */
+    unservable: string[];
+    /** The enabled countries, then every selected code that is not one, so it can be removed. */
+    options: ShipToCountryOption[];
+}
+/**
+ * The ACTIVE store's ship-to countries (`admin.shipping.shipToCountries`): which countries its
+ * storefront offers at checkout, and to which an order may be addressed. Reading needs any
+ * administrator permission on the store; `set` needs `UpdateChannel`.
+ *
+ * The engine owns every rule (how codes are read, which are offered, which are unservable): ask
+ * {@link preview} for a list that is not saved.
+ */
+export interface ShipToCountriesModule {
+    /**
+     * The list as checkout applies it.
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<ShipToCountries>;
+    /**
+     * How a list WOULD read once stored, without saving anything. Refused as {@link set} refuses.
+     *
+     * @effect read
+     */
+    preview(countryCodes: readonly string[], options?: Call): Promise<ShipToCountries>;
+    /**
+     * Replace the list, and answer it as checkout now applies it. Codes are trimmed, upper-cased
+     * and de-duplicated. An empty list means every enabled country, never "ships nowhere".
+     *
+     * Refused `SHIP_TO_COUNTRIES_INVALID` (`ValidationError`, one `details[]` entry per offending
+     * entry, `field` = `countryCodes.<index>`) for an entry that is not a two-letter ISO-3166 code,
+     * or more than 300 entries; `FORBIDDEN` / `CHANNEL_ACCESS_DENIED` without `UpdateChannel`.
+     * A two-letter code that is not an enabled country is stored and reported in `unservable`.
+     *
+     * Narrowing the list changes which countries shoppers may order to.
+     *
+     * @effect write
+     */
+    set(countryCodes: readonly string[], options?: Call): Promise<ShipToCountries>;
+}
+export declare const SHIP_TO_COUNTRIES_QUERY = "\n  query ShipToCountries {\n    shipToCountries { \n  gate\n  reason\n  selected\n  served\n  unservable\n  options { code name enabled }\n }\n  }\n";
+export declare const PREVIEW_SHIP_TO_COUNTRIES_QUERY = "\n  query PreviewShipToCountries($countryCodes: [String!]!) {\n    previewShipToCountries(countryCodes: $countryCodes) { \n  gate\n  reason\n  selected\n  served\n  unservable\n  options { code name enabled }\n }\n  }\n";
+export declare const SET_SHIP_TO_COUNTRIES_MUTATION = "\n  mutation SetShipToCountries($countryCodes: [String!]!) {\n    setShipToCountries(countryCodes: $countryCodes) { \n  gate\n  reason\n  selected\n  served\n  unservable\n  options { code name enabled }\n }\n  }\n";
+export declare function createShipToCountriesModule(transport: Transport): ShipToCountriesModule;

package/dist/shipping/ship-to-countries.js

@@ -0,0 +1,47 @@
+const VIEW_FIELDS = /* GraphQL */ `
+  gate
+  reason
+  selected
+  served
+  unservable
+  options { code name enabled }
+`;
+export const SHIP_TO_COUNTRIES_QUERY = /* GraphQL */ `
+  query ShipToCountries {
+    shipToCountries { ${VIEW_FIELDS} }
+  }
+`;
+export const PREVIEW_SHIP_TO_COUNTRIES_QUERY = /* GraphQL */ `
+  query PreviewShipToCountries($countryCodes: [String!]!) {
+    previewShipToCountries(countryCodes: $countryCodes) { ${VIEW_FIELDS} }
+  }
+`;
+export const SET_SHIP_TO_COUNTRIES_MUTATION = /* GraphQL */ `
+  mutation SetShipToCountries($countryCodes: [String!]!) {
+    setShipToCountries(countryCodes: $countryCodes) { ${VIEW_FIELDS} }
+  }
+`;
+export function createShipToCountriesModule(transport) {
+    return {
+        async get(options) {
+            const data = await transport.graphql({ api: 'admin', query: SHIP_TO_COUNTRIES_QUERY }, options);
+            return data.shipToCountries;
+        },
+        async preview(countryCodes, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: PREVIEW_SHIP_TO_COUNTRIES_QUERY,
+                variables: { countryCodes: [...countryCodes] },
+            }, options);
+            return data.previewShipToCountries;
+        },
+        async set(countryCodes, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_SHIP_TO_COUNTRIES_MUTATION,
+                variables: { countryCodes: [...countryCodes] },
+            }, options);
+            return data.setShipToCountries;
+        },
+    };
+}

package/dist/stock/by-location.d.ts

@@ -0,0 +1,86 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { ListOptions } from '../types.js';
+import type { StockMovementType } from './index.js';
+/** One variant's stock level at one location. */
+export interface LocationStockLevel {
+    /** The stock level's own id. */
+    id: string;
+    variantId: string;
+    sku: string;
+    variantName: string;
+    /** The variant's product, for its name and picture. */
+    product: {
+        id: string;
+        name: string;
+        featuredAsset: {
+            id: string;
+            preview: string;
+        } | null;
+    };
+    /** Units the location holds. */
+    onHand: number;
+    /** Of those, the units reserved for orders. */
+    allocated: number;
+    /** When the level last changed. */
+    updatedAt: string;
+}
+export interface LocationStockLevelFilter extends ListOptions {
+    /** Matches the SKU or the variant's name, ignoring case. Blank searches nothing. */
+    search?: string;
+    /** By units on hand: `DESC` (most first, the default) or `ASC`. */
+    sort?: 'ASC' | 'DESC';
+}
+/** One line of a location's stock ledger. */
+export interface LocationStockMovement {
+    id: string;
+    createdAt: string;
+    type: StockMovementType;
+    /**
+     * The movement's own signed quantity as the engine stores it. A `SALE` is negative; a
+     * `RELEASE` is stored positive although it lowers `allocated`.
+     */
+    quantity: number;
+    variantId: string;
+    sku: string;
+    variantName: string;
+    /** The order the movement was made for (an allocation, a sale, a release, …), else null. */
+    order: {
+        id: string;
+        code: string;
+    } | null;
+}
+/**
+ * What one stock location holds and what moved there, a page at a time. The location must be
+ * the store's own: another store's, or an id that does not exist, is refused
+ * `LOCATION_NOT_IN_CHANNEL` (→ `ValidationError`), never read; a credential restricted with
+ * `locationIds` is refused `LOCATION_NOT_ALLOWED` (→ `PermissionDeniedError`) at a location it
+ * does not hold. A location several stores share lists only this store's variants.
+ */
+export interface StockByLocationReads {
+    /**
+     * The variants stocked at `locationId`, by units on hand (most first unless `sort` says
+     * `ASC`); `limit` defaults to 25 and the engine answers at most 200 per page. A variant whose
+     * level row was never written there is not listed.
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    levelsAt(locationId: string, filter?: LocationStockLevelFilter): Promise<Page<LocationStockLevel>>;
+    /**
+     * The stock ledger at `locationId`, newest first; `limit` defaults to 25. It lists the
+     * movements the engine records (allocations, sales, releases, cancellations, returns and
+     * adjustments); a bulk stock import writes the levels directly and is not on it.
+     *
+     * Known limit: at a location several stores share, a variant that more than one of them sells
+     * also carries the other stores' order movements, whose order this store cannot read. The
+     * engine then fails the whole page (`GRAPHQL_ERROR`, "Cannot return null for non-nullable
+     * field") instead of leaving the row out; the levels read is not affected.
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    movementsAt(locationId: string, filter?: ListOptions): Promise<Page<LocationStockMovement>>;
+}
+export declare const STOCK_LEVELS_AT_LOCATION_QUERY = "\n  query StockLevelsAtLocation($locationId: ID!, $options: StockLevelListOptions) {\n    stockLevelsByLocation(locationId: $locationId, options: $options) {\n      items {\n        id\n        stockOnHand\n        stockAllocated\n        updatedAt\n        productVariant {\n          id\n          name\n          sku\n          product { id name featuredAsset { id preview } }\n        }\n      }\n      totalItems\n    }\n  }\n";
+export declare const STOCK_MOVEMENTS_AT_LOCATION_QUERY = "\n  query StockMovementsAtLocation($locationId: ID!, $options: StockMovementListOptions) {\n    stockMovementsByLocation(locationId: $locationId, options: $options) {\n      items {\n        id\n        createdAt\n        type\n        quantity\n        productVariant { id name sku }\n        orderLine { order { id code } }\n      }\n      totalItems\n    }\n  }\n";
+export declare function createStockByLocationReads(transport: Transport): StockByLocationReads;